diff --git a/Gemfile.lock b/Gemfile.lock index fc99ad9f..f8330b0a 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -20,6 +20,7 @@ GEM docile (1.4.0) json (2.6.2) method_source (1.0.0) + netrc (0.11.0) parallel (1.22.1) parser (3.1.2.1) ast (~> 2.4.1) @@ -31,6 +32,11 @@ GEM pry (>= 0.13, < 0.15) rainbow (3.1.1) rake (13.0.6) + rbi (0.0.15) + ast + parser (>= 2.6.4.0) + sorbet-runtime (>= 0.5.9204) + unparser redcarpet (3.5.1) regexp_parser (2.5.0) rexml (3.2.5) @@ -75,12 +81,41 @@ GEM simplecov_json_formatter (~> 0.1) simplecov-html (0.12.3) simplecov_json_formatter (0.1.4) - sorbet (0.5.10365) - sorbet-static (= 0.5.10365) - sorbet-runtime (0.5.10365) - sorbet-static (0.5.10365-x86_64-linux) + sorbet (0.5.10346) + sorbet-static (= 0.5.10346) + sorbet-runtime (0.5.10346) + sorbet-static (0.5.10346-universal-darwin-14) + sorbet-static (0.5.10346-universal-darwin-15) + sorbet-static (0.5.10346-universal-darwin-16) + sorbet-static (0.5.10346-universal-darwin-17) + sorbet-static (0.5.10346-universal-darwin-18) + sorbet-static (0.5.10346-universal-darwin-19) + sorbet-static (0.5.10346-universal-darwin-20) + sorbet-static (0.5.10346-universal-darwin-21) + sorbet-static (0.5.10346-universal-darwin-22) + sorbet-static (0.5.10346-x86_64-linux) + sorbet-static-and-runtime (0.5.10346) + sorbet (= 0.5.10346) + sorbet-runtime (= 0.5.10346) + spoom (1.1.12) + sorbet (>= 0.5.9204) + sorbet-runtime (>= 0.5.9204) + thor (>= 0.19.2) + tapioca (0.9.4) + bundler (>= 1.17.3) + netrc (>= 0.11.0) + parallel (>= 1.21.0) + pry (>= 0.12.2) + rbi (~> 0.0.0, >= 0.0.14) + sorbet-static-and-runtime (>= 0.5.9204) + spoom (~> 1.1.0, >= 1.1.11) + thor (>= 1.2.0) + yard-sorbet thor (1.2.1) unicode-display_width (2.2.0) + unparser (0.6.5) + diff-lcs (~> 1.3) + parser (>= 3.1.0) webrick (1.7.0) yard (0.9.28) webrick (~> 1.7.0) @@ -101,7 +136,8 @@ DEPENDENCIES rubocop-rspec (~> 2.12.1) rubocop-sorbet (~> 0.6.0) sorbet (~> 0.5.9204) + tapioca (~> 0.9.4) yard-sorbet! BUNDLED WITH - 2.3.20 + 2.3.13 diff --git a/Rakefile b/Rakefile index 58e7eed6..3a326798 100644 --- a/Rakefile +++ b/Rakefile @@ -12,21 +12,6 @@ RSpec::Core::RakeTask.new(:spec) RuboCop::RakeTask.new(:rubocop) YARD::Rake::YardocTask.new -desc 'Update sorbet rbi files' -task :rbi do - sh 'bundle update' - sh 'bundle clean' - sh 'rm -r sorbet/rbi/{gems,hidden-definitions,sorbet-typed,todo.rbi}' - sh 'bundle exec srb rbi sorbet-typed' - sh 'bundle exec srb rbi gems' - sh 'bundle exec srb rbi hidden-definitions' - sh 'bundle exec srb rbi todo' - # sadly, the above commands don't limit themselves to the files/folders that they describe - sh 'git checkout -- sorbet/rbi/contexts' - # this is a weird and unnecessary artifact, just delete it - sh 'rm sorbet/rbi/gems/yard-sorbet.rbi' -end - desc 'Typecheck files with sorbet' namespace :typecheck do |typecheck_namespace| desc 'Typecheck Gemfile' diff --git a/bin/tapioca b/bin/tapioca new file mode 100755 index 00000000..e723bd5a --- /dev/null +++ b/bin/tapioca @@ -0,0 +1,27 @@ +#!/usr/bin/env ruby +# frozen_string_literal: true + +# +# This file was generated by Bundler. +# +# The application 'tapioca' is installed as part of a gem, and +# this file is here to facilitate running it. +# + +ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__) + +bundle_binstub = File.expand_path('bundle', __dir__) + +if File.file?(bundle_binstub) + if /This file was generated by Bundler/.match?(File.read(bundle_binstub, 300)) + load(bundle_binstub) + else + abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. +Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") + end +end + +require 'rubygems' +require 'bundler/setup' + +load Gem.bin_path('tapioca', 'tapioca') diff --git a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi b/sorbet/rbi/annotations/rainbow.rbi similarity index 89% rename from sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi rename to sorbet/rbi/annotations/rainbow.rbi index abbae7b2..60ba90a9 100644 --- a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +++ b/sorbet/rbi/annotations/rainbow.rbi @@ -1,13 +1,11 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rainbow/all/rainbow.rbi -# -# typed: strong +# typed: strict + +# DO NOT EDIT MANUALLY +# This file was pulled from a central RBI files repository. +# Please run `bin/tapioca annotations` to update it. module Rainbow + # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12 sig { returns(T::Boolean) } attr_accessor :enabled @@ -15,18 +13,13 @@ module Rainbow sig { returns(Symbol) } attr_reader :ground - sig do - params( - ground: Symbol, - values: T.any([Integer], [Integer, Integer, Integer]) - ).returns(Color) - end + sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) } def self.build(ground, values); end sig { params(hex: String).returns([Integer, Integer, Integer]) } def self.parse_hex_color(hex); end - class Indexed < Color + class Indexed < Rainbow::Color sig { returns(Integer) } attr_reader :num @@ -37,35 +30,35 @@ module Rainbow def codes; end end - class Named < Indexed + class Named < Rainbow::Color::Indexed NAMES = T.let(nil, T::Hash[Symbol, Integer]) + sig { params(ground: Symbol, name: Symbol).void } + def initialize(ground, name); end + sig { returns(T::Array[Symbol]) } def self.color_names; end sig { returns(String) } def self.valid_names; end - - sig { params(ground: Symbol, name: Symbol).void } - def initialize(ground, name); end end - class RGB < Indexed + class RGB < Rainbow::Color::Indexed sig { returns(Integer) } - attr_accessor :r, :g, :b - - sig { params(value: Numeric).returns(Integer) } - def to_ansi_domain(value); end + attr_reader :r, :g, :b sig { params(ground: Symbol, values: Integer).void } def initialize(ground, *values); end sig { returns(T::Array[Integer]) } def codes; end + + sig { params(value: Numeric).returns(Integer) } + def self.to_ansi_domain(value); end end - class X11Named < RGB - include X11ColorNames + class X11Named < Rainbow::Color::RGB + include Rainbow::X11ColorNames sig { returns(T::Array[Symbol]) } def self.color_names; end @@ -251,7 +244,7 @@ module Rainbow def self.wrap_with_sgr(string, codes); end sig { params(string: String).returns(String) } - def uncolor(string); end + def self.uncolor(string); end end VERSION = T.let(nil, String) diff --git a/sorbet/rbi/gems/ast.rbi b/sorbet/rbi/gems/ast.rbi deleted file mode 100644 index 2b18c4ad..00000000 --- a/sorbet/rbi/gems/ast.rbi +++ /dev/null @@ -1,49 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi -# -# ast-2.4.2 - -module AST -end -class AST::Node - def +(array); end - def <<(element); end - def ==(other); end - def append(element); end - def assign_properties(properties); end - def children; end - def clone; end - def concat(array); end - def deconstruct; end - def dup; end - def eql?(other); end - def fancy_type; end - def hash; end - def initialize(type, children = nil, properties = nil); end - def inspect(indent = nil); end - def original_dup; end - def to_a; end - def to_ast; end - def to_s(indent = nil); end - def to_sexp(indent = nil); end - def to_sexp_array; end - def type; end - def updated(type = nil, children = nil, properties = nil); end -end -class AST::Processor - include AST::Processor::Mixin -end -module AST::Processor::Mixin - def handler_missing(node); end - def process(node); end - def process_all(nodes); end -end -module AST::Sexp - def s(type, *children); end -end diff --git a/sorbet/rbi/gems/ast@2.4.2.rbi b/sorbet/rbi/gems/ast@2.4.2.rbi new file mode 100644 index 00000000..24bebf4f --- /dev/null +++ b/sorbet/rbi/gems/ast@2.4.2.rbi @@ -0,0 +1,584 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `ast` gem. +# Please instead update this file by running `bin/tapioca gem ast`. + +# {AST} is a library for manipulating abstract syntax trees. +# +# It embraces immutability; each AST node is inherently frozen at +# creation, and updating a child node requires recreating that node +# and its every parent, recursively. +# This is a design choice. It does create some pressure on +# garbage collector, but completely eliminates all concurrency +# and aliasing problems. +# +# See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for +# additional recommendations and design patterns. +# +# source://ast-2.4.2/lib/ast.rb:13 +module AST; end + +# Node is an immutable class, instances of which represent abstract +# syntax tree nodes. It combines semantic information (i.e. anything +# that affects the algorithmic properties of a program) with +# meta-information (line numbers or compiler intermediates). +# +# Notes on inheritance +# ==================== +# +# The distinction between semantics and metadata is important. Complete +# semantic information should be contained within just the {#type} and +# {#children} of a Node instance; in other words, if an AST was to be +# stripped of all meta-information, it should remain a valid AST which +# could be successfully processed to yield a result with the same +# algorithmic properties. +# +# Thus, Node should never be inherited in order to define methods which +# affect or return semantic information, such as getters for `class_name`, +# `superclass` and `body` in the case of a hypothetical `ClassNode`. The +# correct solution is to use a generic Node with a {#type} of `:class` +# and three children. See also {Processor} for tips on working with such +# ASTs. +# +# On the other hand, Node can and should be inherited to define +# application-specific metadata (see also {#initialize}) or customize the +# printing format. It is expected that an application would have one or two +# such classes and use them across the entire codebase. +# +# The rationale for this pattern is extensibility and maintainability. +# Unlike static ones, dynamic languages do not require the presence of a +# predefined, rigid structure, nor does it improve dispatch efficiency, +# and while such a structure can certainly be defined, it does not add +# any value but incurs a maintaining cost. +# For example, extending the AST even with a transformation-local +# temporary node type requires making globally visible changes to +# the codebase. +# +# source://ast-2.4.2/lib/ast/node.rb:40 +class AST::Node + # Constructs a new instance of Node. + # + # The arguments `type` and `children` are converted with `to_sym` and + # `to_a` respectively. Additionally, the result of converting `children` + # is frozen. While mutating the arguments is generally considered harmful, + # the most common case is to pass an array literal to the constructor. If + # your code does not expect the argument to be frozen, use `#dup`. + # + # The `properties` hash is passed to {#assign_properties}. + # + # @return [Node] a new instance of Node + # + # source://ast-2.4.2/lib/ast/node.rb:72 + def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end + + # Concatenates `array` with `children` and returns the resulting node. + # + # @return [AST::Node] + # + # source://ast-2.4.2/lib/ast/node.rb:168 + def +(array); end + + # Appends `element` to `children` and returns the resulting node. + # + # @return [AST::Node] + # + # source://ast-2.4.2/lib/ast/node.rb:177 + def <<(element); end + + # Compares `self` to `other`, possibly converting with `to_ast`. Only + # `type` and `children` are compared; metadata is deliberately ignored. + # + # @return [Boolean] + # + # source://ast-2.4.2/lib/ast/node.rb:153 + def ==(other); end + + # Appends `element` to `children` and returns the resulting node. + # + # @return [AST::Node] + # + # source://ast-2.4.2/lib/ast/node.rb:177 + def append(element); end + + # Returns the children of this node. + # The returned value is frozen. + # The to_a alias is useful for decomposing nodes concisely. + # For example: + # + # node = s(:gasgn, :$foo, s(:integer, 1)) + # var_name, value = *node + # p var_name # => :$foo + # p value # => (integer 1) + # + # @return [Array] + # + # source://ast-2.4.2/lib/ast/node.rb:56 + def children; end + + # Nodes are already frozen, so there is no harm in returning the + # current node as opposed to initializing from scratch and freezing + # another one. + # + # @return self + # + # source://ast-2.4.2/lib/ast/node.rb:115 + def clone; end + + # Concatenates `array` with `children` and returns the resulting node. + # + # @return [AST::Node] + # + # source://ast-2.4.2/lib/ast/node.rb:168 + def concat(array); end + + # Enables matching for Node, where type is the first element + # and the children are remaining items. + # + # @return [Array] + # + # source://ast-2.4.2/lib/ast/node.rb:253 + def deconstruct; end + + # Nodes are already frozen, so there is no harm in returning the + # current node as opposed to initializing from scratch and freezing + # another one. + # + # @return self + # + # source://ast-2.4.2/lib/ast/node.rb:115 + def dup; end + + # Test if other object is equal to + # + # @param other [Object] + # @return [Boolean] + # + # source://ast-2.4.2/lib/ast/node.rb:85 + def eql?(other); end + + # Returns the precomputed hash value for this node + # + # @return [Fixnum] + # + # source://ast-2.4.2/lib/ast/node.rb:61 + def hash; end + + # Converts `self` to a s-expression ruby string. + # The code return will recreate the node, using the sexp module s() + # + # @param indent [Integer] Base indentation level. + # @return [String] + # + # source://ast-2.4.2/lib/ast/node.rb:211 + def inspect(indent = T.unsafe(nil)); end + + # Returns the children of this node. + # The returned value is frozen. + # The to_a alias is useful for decomposing nodes concisely. + # For example: + # + # node = s(:gasgn, :$foo, s(:integer, 1)) + # var_name, value = *node + # p var_name # => :$foo + # p value # => (integer 1) + # + # @return [Array] + # + # source://ast-2.4.2/lib/ast/node.rb:56 + def to_a; end + + # @return [AST::Node] self + # + # source://ast-2.4.2/lib/ast/node.rb:229 + def to_ast; end + + # Converts `self` to a pretty-printed s-expression. + # + # @param indent [Integer] Base indentation level. + # @return [String] + # + # source://ast-2.4.2/lib/ast/node.rb:187 + def to_s(indent = T.unsafe(nil)); end + + # Converts `self` to a pretty-printed s-expression. + # + # @param indent [Integer] Base indentation level. + # @return [String] + # + # source://ast-2.4.2/lib/ast/node.rb:187 + def to_sexp(indent = T.unsafe(nil)); end + + # Converts `self` to an Array where the first element is the type as a Symbol, + # and subsequent elements are the same representation of its children. + # + # @return [Array] + # + # source://ast-2.4.2/lib/ast/node.rb:237 + def to_sexp_array; end + + # Returns the type of this node. + # + # @return [Symbol] + # + # source://ast-2.4.2/lib/ast/node.rb:43 + def type; end + + # Returns a new instance of Node where non-nil arguments replace the + # corresponding fields of `self`. + # + # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield + # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would + # yield `(foo)`. + # + # If the resulting node would be identical to `self`, does nothing. + # + # @param type [Symbol, nil] + # @param children [Array, nil] + # @param properties [Hash, nil] + # @return [AST::Node] + # + # source://ast-2.4.2/lib/ast/node.rb:133 + def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end + + protected + + # By default, each entry in the `properties` hash is assigned to + # an instance variable in this instance of Node. A subclass should define + # attribute readers for such variables. The values passed in the hash + # are not frozen or whitelisted; such behavior can also be implemented + # by subclassing Node and overriding this method. + # + # @return [nil] + # + # source://ast-2.4.2/lib/ast/node.rb:98 + def assign_properties(properties); end + + # Returns `@type` with all underscores replaced by dashes. This allows + # to write symbol literals without quotes in Ruby sources and yet have + # nicely looking s-expressions. + # + # @return [String] + # + # source://ast-2.4.2/lib/ast/node.rb:264 + def fancy_type; end + + private + + def original_dup; end +end + +# This class includes {AST::Processor::Mixin}; however, it is +# deprecated, since the module defines all of the behaviors that +# the processor includes. Any new libraries should use +# {AST::Processor::Mixin} instead of subclassing this. +# +# @deprecated Use {AST::Processor::Mixin} instead. +# +# source://ast-2.4.2/lib/ast/processor.rb:8 +class AST::Processor + include ::AST::Processor::Mixin +end + +# The processor module is a module which helps transforming one +# AST into another. In a nutshell, the {#process} method accepts +# a {Node} and dispatches it to a handler corresponding to its +# type, and returns a (possibly) updated variant of the node. +# +# The processor module has a set of associated design patterns. +# They are best explained with a concrete example. Let's define a +# simple arithmetic language and an AST format for it: +# +# Terminals (AST nodes which do not have other AST nodes inside): +# +# * `(integer )`, +# +# Nonterminals (AST nodes with other nodes as children): +# +# * `(add )`, +# * `(multiply )`, +# * `(divide )`, +# * `(negate )`, +# * `(store )`: stores value of `` +# into a variable named ``, +# * `(load )`: loads value of a variable named +# ``, +# * `(each ...)`: computes each of the ``s and +# prints the result. +# +# All AST nodes have the same Ruby class, and therefore they don't +# know how to traverse themselves. (A solution which dynamically +# checks the type of children is possible, but is slow and +# error-prone.) So, a class including the module which knows how +# to traverse the entire tree should be defined. Such classes +# have a handler for each nonterminal node which recursively +# processes children nodes: +# +# require 'ast' +# +# class ArithmeticsProcessor +# include AST::Processor::Mixin +# # This method traverses any binary operators such as (add) +# # or (multiply). +# def process_binary_op(node) +# # Children aren't decomposed automatically; it is +# # suggested to use Ruby multiple assignment expansion, +# # as it is very convenient here. +# left_expr, right_expr = *node +# +# # AST::Node#updated won't change node type if nil is +# # passed as a first argument, which allows to reuse the +# # same handler for multiple node types using `alias' +# # (below). +# node.updated(nil, [ +# process(left_expr), +# process(right_expr) +# ]) +# end +# alias_method :on_add, :process_binary_op +# alias_method :on_multiply, :process_binary_op +# alias_method :on_divide, :process_binary_op +# +# def on_negate(node) +# # It is also possible to use #process_all for more +# # compact code if every child is a Node. +# node.updated(nil, process_all(node)) +# end +# +# def on_store(node) +# expr, variable_name = *node +# +# # Note that variable_name is not a Node and thus isn't +# # passed to #process. +# node.updated(nil, [ +# process(expr), +# variable_name +# ]) +# end +# +# # (load) is effectively a terminal node, and so it does +# # not need an explicit handler, as the following is the +# # default behavior. Essentially, for any nodes that don't +# # have a defined handler, the node remains unchanged. +# def on_load(node) +# nil +# end +# +# def on_each(node) +# node.updated(nil, process_all(node)) +# end +# end +# +# Let's test our ArithmeticsProcessor: +# +# include AST::Sexp +# expr = s(:add, s(:integer, 2), s(:integer, 2)) +# +# p ArithmeticsProcessor.new.process(expr) == expr # => true +# +# As expected, it does not change anything at all. This isn't +# actually very useful, so let's now define a Calculator, which +# will compute the expression values: +# +# # This Processor folds nonterminal nodes and returns an +# # (integer) terminal node. +# class ArithmeticsCalculator < ArithmeticsProcessor +# def compute_op(node) +# # First, node children are processed and then unpacked +# # to local variables. +# nodes = process_all(node) +# +# if nodes.all? { |node| node.type == :integer } +# # If each of those nodes represents a literal, we can +# # fold this node! +# values = nodes.map { |node| node.children.first } +# AST::Node.new(:integer, [ +# yield(values) +# ]) +# else +# # Otherwise, we can just leave the current node in the +# # tree and only update it with processed children +# # nodes, which can be partially folded. +# node.updated(nil, nodes) +# end +# end +# +# def on_add(node) +# compute_op(node) { |left, right| left + right } +# end +# +# def on_multiply(node) +# compute_op(node) { |left, right| left * right } +# end +# end +# +# Let's check: +# +# p ArithmeticsCalculator.new.process(expr) # => (integer 4) +# +# Excellent, the calculator works! Now, a careful reader could +# notice that the ArithmeticsCalculator does not know how to +# divide numbers. What if we pass an expression with division to +# it? +# +# expr_with_division = \ +# s(:add, +# s(:integer, 1), +# s(:divide, +# s(:add, s(:integer, 8), s(:integer, 4)), +# s(:integer, 3))) # 1 + (8 + 4) / 3 +# +# folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division) +# p folded_expr_with_division +# # => (add +# # (integer 1) +# # (divide +# # (integer 12) +# # (integer 3))) +# +# As you can see, the expression was folded _partially_: the inner +# `(add)` node which could be computed was folded to +# `(integer 12)`, the `(divide)` node is left as-is because there +# is no computing handler for it, and the root `(add)` node was +# also left as it is because some of its children were not +# literals. +# +# Note that this partial folding is only possible because the +# _data_ format, i.e. the format in which the computed values of +# the nodes are represented, is the same as the AST itself. +# +# Let's extend our ArithmeticsCalculator class further. +# +# class ArithmeticsCalculator +# def on_divide(node) +# compute_op(node) { |left, right| left / right } +# end +# +# def on_negate(node) +# # Note how #compute_op works regardless of the operator +# # arity. +# compute_op(node) { |value| -value } +# end +# end +# +# Now, let's apply our renewed ArithmeticsCalculator to a partial +# result of previous evaluation: +# +# p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5) +# +# Five! Excellent. This is also pretty much how CRuby 1.8 executed +# its programs. +# +# Now, let's do some automated bug searching. Division by zero is +# an error, right? So if we could detect that someone has divided +# by zero before the program is even run, that could save some +# debugging time. +# +# class DivisionByZeroVerifier < ArithmeticsProcessor +# class VerificationFailure < Exception; end +# +# def on_divide(node) +# # You need to process the children to handle nested divisions +# # such as: +# # (divide +# # (integer 1) +# # (divide (integer 1) (integer 0)) +# left, right = process_all(node) +# +# if right.type == :integer && +# right.children.first == 0 +# raise VerificationFailure, "Ouch! This code divides by zero." +# end +# end +# +# def divides_by_zero?(ast) +# process(ast) +# false +# rescue VerificationFailure +# true +# end +# end +# +# nice_expr = \ +# s(:divide, +# s(:add, s(:integer, 10), s(:integer, 2)), +# s(:integer, 4)) +# +# p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr) +# # => false. Good. +# +# bad_expr = \ +# s(:add, s(:integer, 10), +# s(:divide, s(:integer, 1), s(:integer, 0))) +# +# p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr) +# # => true. WHOOPS. DO NOT RUN THIS. +# +# Of course, this won't detect more complex cases... unless you +# use some partial evaluation before! The possibilites are +# endless. Have fun. +# +# source://ast-2.4.2/lib/ast/processor/mixin.rb:240 +module AST::Processor::Mixin + # Default handler. Does nothing. + # + # @param node [AST::Node] + # @return [AST::Node, nil] + # + # source://ast-2.4.2/lib/ast/processor/mixin.rb:284 + def handler_missing(node); end + + # Dispatches `node`. If a node has type `:foo`, then a handler + # named `on_foo` is invoked with one argument, the `node`; if + # there isn't such a handler, {#handler_missing} is invoked + # with the same argument. + # + # If the handler returns `nil`, `node` is returned; otherwise, + # the return value of the handler is passed along. + # + # @param node [AST::Node, nil] + # @return [AST::Node, nil] + # + # source://ast-2.4.2/lib/ast/processor/mixin.rb:251 + def process(node); end + + # {#process}es each node from `nodes` and returns an array of + # results. + # + # @param nodes [Array] + # @return [Array] + # + # source://ast-2.4.2/lib/ast/processor/mixin.rb:274 + def process_all(nodes); end +end + +# This simple module is very useful in the cases where one needs +# to define deeply nested ASTs from Ruby code, for example, in +# tests. It should be used like this: +# +# describe YourLanguage::AST do +# include Sexp +# +# it "should correctly parse expressions" do +# YourLanguage.parse("1 + 2 * 3").should == +# s(:add, +# s(:integer, 1), +# s(:multiply, +# s(:integer, 2), +# s(:integer, 3))) +# end +# end +# +# This way the amount of boilerplate code is greatly reduced. +# +# source://ast-2.4.2/lib/ast/sexp.rb:20 +module AST::Sexp + # Creates a {Node} with type `type` and children `children`. + # Note that the resulting node is of the type AST::Node and not a + # subclass. + # This would not pose a problem with comparisons, as {Node#==} + # ignores metadata. + # + # source://ast-2.4.2/lib/ast/sexp.rb:26 + def s(type, *children); end +end diff --git a/sorbet/rbi/gems/bundler-audit.rbi b/sorbet/rbi/gems/bundler-audit.rbi deleted file mode 100644 index 6167c150..00000000 --- a/sorbet/rbi/gems/bundler-audit.rbi +++ /dev/null @@ -1,85 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/bundler-audit/all/bundler-audit.rbi -# -# bundler-audit-0.9.1 - -module Bundler -end -module Bundler::Audit -end -class Anonymous_Struct_1 < Struct - def cve; end - def cve=(_); end - def cvss_v2; end - def cvss_v2=(_); end - def cvss_v3; end - def cvss_v3=(_); end - def date; end - def date=(_); end - def description; end - def description=(_); end - def ghsa; end - def ghsa=(_); end - def id; end - def id=(_); end - def osvdb; end - def osvdb=(_); end - def patched_versions; end - def patched_versions=(_); end - def path; end - def path=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def title; end - def title=(_); end - def unaffected_versions; end - def unaffected_versions=(_); end - def url; end - def url=(_); end -end -class Bundler::Audit::Advisory < Anonymous_Struct_1 - def ==(other); end - def criticality; end - def cve_id; end - def ghsa_id; end - def identifiers; end - def osvdb_id; end - def patched?(version); end - def self.load(path); end - def to_h; end - def to_s; end - def unaffected?(version); end - def vulnerable?(version); end -end -class Bundler::Audit::Database - def advisories(&block); end - def advisories_for(name); end - def check_gem(gem); end - def commit_id; end - def each_advisory_path(&block); end - def each_advisory_path_for(name, &block); end - def git?; end - def initialize(path = nil); end - def inspect; end - def last_updated_at; end - def path; end - def self.download(options = nil); end - def self.exists?(path = nil); end - def self.path; end - def self.update!(options = nil); end - def size; end - def to_s; end - def update!(options = nil); end -end -class Bundler::Audit::Database::DownloadFailed < RuntimeError -end -class Bundler::Audit::Database::UpdateFailed < RuntimeError -end diff --git a/sorbet/rbi/gems/bundler-audit@0.9.1.rbi b/sorbet/rbi/gems/bundler-audit@0.9.1.rbi new file mode 100644 index 00000000..7d173096 --- /dev/null +++ b/sorbet/rbi/gems/bundler-audit@0.9.1.rbi @@ -0,0 +1,341 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `bundler-audit` gem. +# Please instead update this file by running `bin/tapioca gem bundler-audit`. + +# source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:22 +module Bundler::Audit; end + +# Represents an advisory loaded from the {Database}. +# +# source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:38 +class Bundler::Audit::Advisory < ::Struct + # Compares two advisories. + # + # @param other [Advisory] + # @return [Boolean] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:210 + def ==(other); end + + # Determines how critical the vulnerability is. + # + # @return [:none, :low, :medium, :high, :critical, nil] The criticality of the vulnerability based on the CVSS score. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:138 + def criticality; end + + # The CVE identifier. + # + # @return [String, nil] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:93 + def cve_id; end + + # The GHSA (GitHub Security Advisory) identifier + # + # @return [String, nil] + # @since 0.7.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:113 + def ghsa_id; end + + # Return a compacted list of all ids + # + # @return [Array] + # @since 0.7.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:124 + def identifiers; end + + # The OSVDB identifier. + # + # @return [String, nil] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:102 + def osvdb_id; end + + # Checks whether the version is patched against the advisory. + # + # @param version [Gem::Version] The version to compare against {#patched_versions}. + # @return [Boolean] Specifies whether the version is patched against the advisory. + # @since 0.2.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:184 + def patched?(version); end + + # Converts the advisory to a Hash. + # + # @return [Hash{Symbol => Object}] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:219 + def to_h; end + + # Returns the value of attribute id + # + # @return [Object] the current value of id + def to_s; end + + # Checks whether the version is not affected by the advisory. + # + # @param version [Gem::Version] The version to compare against {#unaffected_versions}. + # @return [Boolean] Specifies whether the version is not affected by the advisory. + # @since 0.2.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:167 + def unaffected?(version); end + + # Checks whether the version is vulnerable to the advisory. + # + # @param version [Gem::Version] The version to compare against {#patched_versions}. + # @return [Boolean] Specifies whether the version is vulnerable to the advisory or not. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:199 + def vulnerable?(version); end + + class << self + # Loads the advisory from a YAML file. + # + # @api semipublic + # @param path [String] The path to the advisory YAML file. + # @return [Advisory] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/advisory.rb:50 + def load(path); end + end +end + +# Represents the directory of advisories, grouped by gem name +# and CVE number. +# +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:29 +class Bundler::Audit::Database + # Initializes the Advisory Database. + # + # @param path [String] The path to the advisory database. + # @raise [ArgumentError] The path was not a directory. + # @return [Database] a new instance of Database + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:62 + def initialize(path = T.unsafe(nil)); end + + # Enumerates over every advisory in the database. + # + # @return [Enumerator] If no block is given, an Enumerator will be returned. + # @yield [advisory] If a block is given, it will be passed each advisory. + # @yieldparam advisory [Advisory] An advisory from the database. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:262 + def advisories(&block); end + + # Enumerates over advisories for the given gem. + # + # @param name [String] The gem name to lookup. + # @return [Enumerator] If no block is given, an Enumerator will be returned. + # @yield [advisory] If a block is given, each advisory for the given gem will be yielded. + # @yieldparam advisory [Advisory] An advisory for the given gem. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:285 + def advisories_for(name); end + + # Verifies whether the gem is effected by any advisories. + # + # @param gem [Gem::Specification] The gem to verify. + # @return [Enumerator] If no block is given, an Enumerator will be returned. + # @yield [advisory] If a block is given, it will be passed advisories that effect + # the gem. + # @yieldparam advisory [Advisory] An advisory that effects the specific version of the gem. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:309 + def check_gem(gem); end + + # The last commit ID of the repository. + # + # @return [String, nil] The commit hash or `nil` if the database is not a git repository. + # @since 0.9.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:225 + def commit_id; end + + # Determines if the database is a git repository. + # + # @return [Boolean] + # @since 0.8.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:181 + def git?; end + + # Inspects the database. + # + # @return [String] The inspected database. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:345 + def inspect; end + + # Determines the time when the database was last updated. + # + # @return [Time] + # @since 0.8.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:240 + def last_updated_at; end + + # The path to the advisory database. + # + # @return [String] + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:51 + def path; end + + # The number of advisories within the database. + # + # @return [Integer] The number of advisories. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:325 + def size; end + + # Converts the database to a String. + # + # @return [String] The path to the database. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:335 + def to_s; end + + # Updates the ruby-advisory-db. + # + # @option options + # @param options [Hash] Additional options. + # @return [true, nil] `true` indicates that the update was successful. + # `nil` indicates the database is not a git repository, thus not + # capable of being updated. + # @since 0.8.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:201 + def update!(options = T.unsafe(nil)); end + + protected + + # Enumerates over every advisory path in the database. + # + # @yield [path] The given block will be passed each advisory path. + # @yieldparam path [String] A path to an advisory `.yml` file. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:360 + def each_advisory_path(&block); end + + # Enumerates over the advisories for the given gem. + # + # @param name [String] The gem of the gem. + # @yield [path] The given block will be passed each advisory path. + # @yieldparam path [String] A path to an advisory `.yml` file. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:376 + def each_advisory_path_for(name, &block); end + + class << self + # Downloads the ruby-advisory-db. + # + # @note Requires network access. + # @option options + # @option options + # @param options [Hash] Additional options. + # @raise [DownloadFailed] Indicates that the download failed. + # @return [Dataase] The newly downloaded database. + # @since 0.8.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:117 + def download(options = T.unsafe(nil)); end + + # Tests whether the database exists. + # + # @param path [String] The given path of the database to check. + # @return [Boolean] + # @since 0.8.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:90 + def exists?(path = T.unsafe(nil)); end + + # The default path for the database. + # + # @return [String] The path to the database directory. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:76 + def path; end + + # Updates the ruby-advisory-db. + # + # @deprecated Use {#update!} instead. + # @note Requires network access. + # @option options + # @param options [Hash] Additional options. + # @raise [ArgumentError] Invalid options were given. + # @return [Boolean, nil] Specifies whether the update was successful. + # A `nil` indicates no update was performed. + # @since 0.3.0 + # + # source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:158 + def update!(options = T.unsafe(nil)); end + end +end + +# Default path to the ruby-advisory-db. +# +# @since 0.8.0 +# +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:46 +Bundler::Audit::Database::DEFAULT_PATH = T.let(T.unsafe(nil), String) + +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:31 +class Bundler::Audit::Database::DownloadFailed < ::RuntimeError; end + +# Git URL of the ruby-advisory-db. +# +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:38 +Bundler::Audit::Database::URL = T.let(T.unsafe(nil), String) + +# Path to the user's copy of the ruby-advisory-db. +# +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:41 +Bundler::Audit::Database::USER_PATH = T.let(T.unsafe(nil), String) + +# source://bundler-audit-0.9.1/lib/bundler/audit/database.rb:34 +class Bundler::Audit::Database::UpdateFailed < ::RuntimeError; end + +# Defines the `bundle:audit` rake tasks. +# +# source://bundler-audit-0.9.1/lib/bundler/audit/task.rb:8 +class Bundler::Audit::Task < ::Rake::TaskLib + # Initializes the task. + # + # @return [Task] a new instance of Task + # + # source://bundler-audit-0.9.1/lib/bundler/audit/task.rb:15 + def initialize; end + + protected + + # Runs the `bundler-audit` command with the additional arguments. + # + # @note If the `bundler-audit` command exits with an error, the rake task + # will also exit with the same error code. + # @param arguments [Array] Additional command-line arguments for `bundler-audit`. + # @raise [CommandNotFound] The `bundler-audit` command could not be executed or was not found. + # @return [true] The `bundler-audit` command successfully exited. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/task.rb:62 + def bundler_audit(*arguments); end + + # Defines the `bundle:audit` and `bundle:audit:update` task. + # + # source://bundler-audit-0.9.1/lib/bundler/audit/task.rb:24 + def define; end +end + +# source://bundler-audit-0.9.1/lib/bundler/audit/task.rb:9 +class Bundler::Audit::Task::CommandNotFound < ::RuntimeError; end + +# bundler-audit version +# +# source://bundler-audit-0.9.1/lib/bundler/audit/version.rb:21 +Bundler::Audit::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/byebug.rbi b/sorbet/rbi/gems/byebug.rbi deleted file mode 100644 index 4ff64263..00000000 --- a/sorbet/rbi/gems/byebug.rbi +++ /dev/null @@ -1,1041 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/byebug/all/byebug.rbi -# -# byebug-11.1.3 - -module Byebug - def add_catchpoint(arg0); end - def breakpoints; end - def catchpoints; end - def contexts; end - def current_context; end - def debug_load(*arg0); end - def displays; end - def displays=(arg0); end - def init_file; end - def init_file=(arg0); end - def lock; end - def mode; end - def mode=(arg0); end - def post_mortem=(arg0); end - def post_mortem?; end - def raised_exception; end - def rc_dirs; end - def run_init_script; end - def run_rc_file(rc_file); end - def self.actual_control_port; end - def self.actual_port; end - def self.add_catchpoint(arg0); end - def self.attach; end - def self.breakpoints; end - def self.catchpoints; end - def self.client; end - def self.contexts; end - def self.control; end - def self.current_context; end - def self.debug_load(*arg0); end - def self.handle_post_mortem; end - def self.interrupt; end - def self.load_settings; end - def self.lock; end - def self.parse_host_and_port(host_port_spec); end - def self.post_mortem=(arg0); end - def self.post_mortem?; end - def self.raised_exception; end - def self.server; end - def self.spawn(host = nil, port = nil); end - def self.start; end - def self.start_client(host = nil, port = nil); end - def self.start_control(host = nil, port = nil); end - def self.start_server(host = nil, port = nil); end - def self.started?; end - def self.stop; end - def self.stoppable?; end - def self.thread_context(arg0); end - def self.tracing=(arg0); end - def self.tracing?; end - def self.unlock; end - def self.verbose=(arg0); end - def self.verbose?; end - def self.wait_connection; end - def self.wait_connection=(arg0); end - def start; end - def started?; end - def stop; end - def stoppable?; end - def thread_context(arg0); end - def tracing=(arg0); end - def tracing?; end - def unlock; end - def verbose=(arg0); end - def verbose?; end - extend Byebug - include Byebug::Helpers::ReflectionHelper -end -module Kernel - def byebug; end - def debugger; end - def remote_byebug(host = nil, port = nil); end -end -module Byebug::Helpers -end -module Byebug::Helpers::ReflectionHelper - def commands; end -end -class Byebug::Context - def at_breakpoint(breakpoint); end - def at_catchpoint(exception); end - def at_end; end - def at_line; end - def at_return(return_value); end - def at_tracing; end - def backtrace; end - def dead?; end - def file(*args, &block); end - def frame; end - def frame=(pos); end - def frame_binding(*arg0); end - def frame_class(*arg0); end - def frame_file(*arg0); end - def frame_line(*arg0); end - def frame_method(*arg0); end - def frame_self(*arg0); end - def full_location; end - def ignored?; end - def ignored_file?(path); end - def interrupt; end - def line(*args, &block); end - def location; end - def processor; end - def resume; end - def self.ignored_files; end - def self.ignored_files=(arg0); end - def self.interface; end - def self.interface=(arg0); end - def self.processor; end - def self.processor=(arg0); end - def stack_size; end - def step_into(*arg0); end - def step_out(*arg0); end - def step_over(*arg0); end - def stop_reason; end - def suspend; end - def suspended?; end - def switch; end - def thnum; end - def thread; end - def tracing; end - def tracing=(arg0); end - extend Forwardable - include Byebug::Helpers::FileHelper -end -class Byebug::DebugThread < Thread - def self.inherited; end -end -class Byebug::Breakpoint - def enabled=(arg0); end - def enabled?; end - def expr; end - def expr=(arg0); end - def hit_condition; end - def hit_condition=(arg0); end - def hit_count; end - def hit_value; end - def hit_value=(arg0); end - def id; end - def initialize(arg0, arg1, arg2); end - def inspect; end - def pos; end - def self.add(file, line, expr = nil); end - def self.first; end - def self.last; end - def self.none?; end - def self.potential_line?(filename, lineno); end - def self.potential_lines(filename); end - def self.potential_lines_with_trace_points(iseq, lines); end - def self.potential_lines_without_trace_points(iseq, lines); end - def self.remove(id); end - def source; end -end -module Byebug::Helpers::FileHelper - def get_line(filename, lineno); end - def get_lines(filename); end - def n_lines(filename); end - def normalize(filename); end - def shortpath(fullpath); end - def virtual_file?(name); end -end -class Byebug::Frame - def _binding; end - def _class; end - def _method; end - def _self; end - def args; end - def c_args; end - def c_frame?; end - def current?; end - def deco_args; end - def deco_block; end - def deco_call; end - def deco_class; end - def deco_file; end - def deco_method; end - def deco_pos; end - def file; end - def initialize(context, pos); end - def line; end - def locals; end - def mark; end - def pos; end - def prefix_and_default(arg_type); end - def ruby_args; end - def to_hash; end - def use_short_style?(arg); end - include Byebug::Helpers::FileHelper -end -module Byebug::Helpers::PathHelper - def all_files; end - def bin_file; end - def gem_files; end - def glob_for(dir); end - def lib_files; end - def root_path; end - def test_files; end -end -module Byebug::Helpers::EvalHelper - def allowing_other_threads; end - def error_eval(str, binding = nil); end - def error_msg(exception); end - def in_new_thread; end - def msg(exception); end - def multiple_thread_eval(expression); end - def safe_eval(str, binding); end - def safe_inspect(var); end - def safe_to_s(var); end - def separate_thread_eval(expression); end - def silent_eval(str, binding = nil); end - def warning_eval(str, binding = nil); end - def warning_msg(exception); end -end -class Byebug::CommandNotFound < NoMethodError - def build_cmd(*args); end - def help; end - def initialize(input, parent = nil); end - def name; end -end -class Byebug::CommandProcessor - def after_repl; end - def at_breakpoint(brkpt); end - def at_catchpoint(exception); end - def at_end; end - def at_line; end - def at_return(return_value); end - def at_tracing; end - def auto_cmds_for(run_level); end - def before_repl; end - def command_list; end - def commands(*args, &block); end - def confirm(*args, &block); end - def context; end - def errmsg(*args, &block); end - def frame(*args, &block); end - def initialize(context, interface = nil); end - def interface; end - def pr(*args, &block); end - def prc(*args, &block); end - def prev_line; end - def prev_line=(arg0); end - def printer; end - def proceed!; end - def process_commands; end - def prompt; end - def prv(*args, &block); end - def puts(*args, &block); end - def repl; end - def run_auto_cmds(run_level); end - def run_cmd(input); end - def safely; end - extend Forwardable - include Byebug::Helpers::EvalHelper -end -module Byebug::Helpers::StringHelper - def camelize(str); end - def deindent(str, leading_spaces: nil); end - def prettify(str); end -end -class Byebug::Setting - def boolean?; end - def help; end - def initialize; end - def integer?; end - def self.[](name); end - def self.[]=(name, value); end - def self.find(shortcut); end - def self.help_all; end - def self.settings; end - def to_s; end - def to_sym; end - def value; end - def value=(arg0); end -end -class Byebug::History - def buffer; end - def clear; end - def default_max_size; end - def ignore?(buf); end - def initialize; end - def last_ids(number); end - def pop; end - def push(cmd); end - def restore; end - def save; end - def size; end - def size=(arg0); end - def specific_max_size(number); end - def to_s(n_cmds); end -end -class Byebug::LocalInterface < Byebug::Interface - def initialize; end - def readline(prompt); end - def with_repl_like_sigint; end - def without_readline_completion; end -end -class Byebug::ScriptInterface < Byebug::Interface - def close; end - def initialize(file, verbose = nil); end - def read_command(prompt); end - def readline(*arg0); end -end -class Byebug::RemoteInterface < Byebug::Interface - def close; end - def confirm(prompt); end - def initialize(socket); end - def print(message); end - def puts(message); end - def read_command(prompt); end - def readline(prompt); end -end -class Byebug::Interface - def autorestore; end - def autosave; end - def close; end - def command_queue; end - def command_queue=(arg0); end - def confirm(prompt); end - def errmsg(message); end - def error; end - def history; end - def history=(arg0); end - def initialize; end - def input; end - def last_if_empty(input); end - def output; end - def prepare_input(prompt); end - def print(message); end - def puts(message); end - def read_command(prompt); end - def read_file(filename); end - def read_input(prompt, save_hist = nil); end - def split_commands(cmd_line); end - include Byebug::Helpers::FileHelper -end -class Byebug::ScriptProcessor < Byebug::CommandProcessor - def after_repl; end - def commands; end - def prompt; end - def repl; end - def without_exceptions; end -end -class Byebug::PostMortemProcessor < Byebug::CommandProcessor - def commands; end - def prompt; end -end -class Byebug::Command - def arguments; end - def confirm(*args, &block); end - def context; end - def errmsg(*args, &block); end - def frame; end - def help(*args, &block); end - def initialize(processor, input = nil); end - def match(*args, &block); end - def pr(*args, &block); end - def prc(*args, &block); end - def print(*args, &block); end - def processor; end - def prv(*args, &block); end - def puts(*args, &block); end - def self.allow_in_control; end - def self.allow_in_control=(arg0); end - def self.allow_in_post_mortem; end - def self.allow_in_post_mortem=(arg0); end - def self.always_run; end - def self.always_run=(arg0); end - def self.columnize(width); end - def self.help; end - def self.match(input); end - def self.to_s; end - extend Forwardable -end -module Byebug::Helpers::ParseHelper - def get_int(str, cmd, min = nil, max = nil); end - def parse_steps(str, cmd); end - def syntax_valid?(code); end - def without_stderr; end -end -class Byebug::SourceFileFormatter - def amend(line, ceiling); end - def amend_final(line); end - def amend_initial(line); end - def annotator; end - def file; end - def initialize(file, annotator); end - def lines(min, max); end - def lines_around(center); end - def max_initial_line; end - def max_line; end - def range_around(center); end - def range_from(min); end - def size; end - include Byebug::Helpers::FileHelper -end -class Byebug::BreakCommand < Byebug::Command - def add_line_breakpoint(file, line); end - def execute; end - def line_breakpoint(location); end - def method_breakpoint(location); end - def self.description; end - def self.regexp; end - def self.short_description; end - def target_object(str); end - def valid_breakpoints_for(path, line); end - include Byebug::Helpers::EvalHelper - include Byebug::Helpers::FileHelper - include Byebug::Helpers::ParseHelper -end -class Byebug::CatchCommand < Byebug::Command - def add(exception); end - def clear; end - def execute; end - def info; end - def remove(exception); end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::EvalHelper -end -class Byebug::ConditionCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::ContinueCommand < Byebug::Command - def execute; end - def modifier; end - def self.description; end - def self.regexp; end - def self.short_description; end - def unconditionally?; end - def until_line?; end - include Byebug::Helpers::ParseHelper -end -class Byebug::DebugCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::EvalHelper -end -class Byebug::DeleteCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::CommandList - def each; end - def initialize(commands); end - def match(input); end - def to_s; end - def width; end - include Enumerable -end -module Byebug::Subcommands - def execute; end - def self.included(command); end - def subcommand_list(*args, &block); end - extend Forwardable -end -module Byebug::Subcommands::ClassMethods - def help; end - def subcommand_list; end - include Byebug::Helpers::ReflectionHelper -end -module Byebug::Helpers::ToggleHelper - def enable_disable_breakpoints(is_enable, args); end - def enable_disable_display(is_enable, args); end - def n_displays; end - def select_breakpoints(is_enable, args); end - include Byebug::Helpers::ParseHelper -end -class Byebug::DisableCommand < Byebug::Command - def self.description; end - def self.regexp; end - def self.short_description; end - extend Byebug::Subcommands::ClassMethods - include Byebug::Subcommands -end -class Byebug::DisableCommand::BreakpointsCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ToggleHelper -end -class Byebug::DisableCommand::DisplayCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ToggleHelper -end -class Byebug::DisplayCommand < Byebug::Command - def display_expression(exp); end - def eval_expr(expression); end - def execute; end - def print_display_expressions; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::EvalHelper -end -module Byebug::Helpers::FrameHelper - def adjust_frame(new_frame); end - def direction(step); end - def frame_err(msg); end - def index_from_start(index); end - def jump_frames(steps); end - def navigate_to_frame(jump_no); end - def out_of_bounds?(pos); end - def switch_to_frame(frame); end -end -class Byebug::DownCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::FrameHelper - include Byebug::Helpers::ParseHelper -end -class Byebug::EditCommand < Byebug::Command - def edit_error(type, file); end - def editor; end - def execute; end - def location(matched); end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::EnableCommand < Byebug::Command - def self.description; end - def self.regexp; end - def self.short_description; end - extend Byebug::Subcommands::ClassMethods - include Byebug::Subcommands -end -class Byebug::EnableCommand::BreakpointsCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ToggleHelper -end -class Byebug::EnableCommand::DisplayCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ToggleHelper -end -class Byebug::FinishCommand < Byebug::Command - def execute; end - def max_frames; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::FrameCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::FrameHelper - include Byebug::Helpers::ParseHelper -end -class Byebug::HelpCommand < Byebug::Command - def command; end - def execute; end - def help_for(input, cmd); end - def help_for_all; end - def self.description; end - def self.regexp; end - def self.short_description; end - def subcommand; end -end -class Byebug::HistoryCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::InfoCommand < Byebug::Command - def self.description; end - def self.regexp; end - def self.short_description; end - extend Byebug::Subcommands::ClassMethods - include Byebug::Subcommands -end -class Byebug::InfoCommand::BreakpointsCommand < Byebug::Command - def execute; end - def info_breakpoint(brkpt); end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::InfoCommand::DisplayCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::InfoCommand::FileCommand < Byebug::Command - def execute; end - def info_file_basic(file); end - def info_file_breakpoints(file); end - def info_file_mtime(file); end - def info_file_sha1(file); end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::FileHelper - include Byebug::Helpers::StringHelper -end -class Byebug::InfoCommand::LineCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::InfoCommand::ProgramCommand < Byebug::Command - def execute; end - def format_stop_reason(stop_reason); end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::InterruptCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::IrbCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - def with_clean_argv; end -end -class Byebug::KillCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::ListCommand < Byebug::Command - def amend_final(*args, &block); end - def auto_range(direction); end - def display_lines(min, max); end - def execute; end - def lower_bound(range); end - def max_line(*args, &block); end - def move(line, size, direction = nil); end - def parse_range(input); end - def range(input); end - def self.description; end - def self.regexp; end - def self.short_description; end - def size(*args, &block); end - def source_file_formatter; end - def split_range(str); end - def upper_bound(range); end - def valid_range?(first, last); end - extend Forwardable - include Byebug::Helpers::FileHelper - include Byebug::Helpers::ParseHelper -end -class Byebug::MethodCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::EvalHelper -end -class Byebug::NextCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::PryCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::QuitCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -module Byebug::Helpers::BinHelper - def executable_file_extensions; end - def find_executable(path, cmd); end - def real_executable?(file); end - def search_paths; end - def which(cmd); end -end -class Byebug::RestartCommand < Byebug::Command - def execute; end - def prepend_byebug_bin(cmd); end - def prepend_ruby_bin(cmd); end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::BinHelper - include Byebug::Helpers::PathHelper -end -class Byebug::SaveCommand < Byebug::Command - def execute; end - def save_breakpoints(file); end - def save_catchpoints(file); end - def save_displays(file); end - def save_settings(file); end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::SetCommand < Byebug::Command - def execute; end - def get_onoff(arg, default); end - def self.description; end - def self.help; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::ShowCommand < Byebug::Command - def execute; end - def self.description; end - def self.help; end - def self.regexp; end - def self.short_description; end -end -class Byebug::SkipCommand < Byebug::Command - def auto_run; end - def execute; end - def initialize_attributes; end - def keep_execution; end - def reset_attributes; end - def self.description; end - def self.file_line; end - def self.file_line=(arg0); end - def self.file_path; end - def self.file_path=(arg0); end - def self.previous_autolist; end - def self.regexp; end - def self.restore_autolist; end - def self.setup_autolist(value); end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::SourceCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::StepCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -module Byebug::Helpers::ThreadHelper - def context_from_thread(thnum); end - def current_thread?(ctx); end - def debug_flag(ctx); end - def display_context(ctx); end - def location(ctx); end - def status_flag(ctx); end - def thread_arguments(ctx); end -end -class Byebug::ThreadCommand < Byebug::Command - def self.description; end - def self.regexp; end - def self.short_description; end - extend Byebug::Subcommands::ClassMethods - include Byebug::Subcommands -end -class Byebug::ThreadCommand::CurrentCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ThreadHelper -end -class Byebug::ThreadCommand::ListCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ThreadHelper -end -class Byebug::ThreadCommand::ResumeCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ThreadHelper -end -class Byebug::ThreadCommand::StopCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ThreadHelper -end -class Byebug::ThreadCommand::SwitchCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ThreadHelper -end -class Byebug::TracevarCommand < Byebug::Command - def execute; end - def on_change(name, value, stop); end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::UndisplayCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::ParseHelper -end -class Byebug::UntracevarCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end -end -class Byebug::UpCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::FrameHelper - include Byebug::Helpers::ParseHelper -end -module Byebug::Helpers::VarHelper - def var_args; end - def var_global; end - def var_instance(str); end - def var_list(ary, binding = nil); end - def var_local; end - include Byebug::Helpers::EvalHelper -end -class Byebug::VarCommand < Byebug::Command - def self.description; end - def self.regexp; end - def self.short_description; end - extend Byebug::Subcommands::ClassMethods - include Byebug::Subcommands -end -class Byebug::VarCommand::AllCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::VarHelper -end -class Byebug::VarCommand::ArgsCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::VarHelper -end -class Byebug::VarCommand::ConstCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - def str_obj; end - include Byebug::Helpers::EvalHelper -end -class Byebug::VarCommand::InstanceCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::VarHelper -end -class Byebug::VarCommand::LocalCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::VarHelper -end -class Byebug::VarCommand::GlobalCommand < Byebug::Command - def execute; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::VarHelper -end -class Byebug::WhereCommand < Byebug::Command - def execute; end - def print_backtrace; end - def self.description; end - def self.regexp; end - def self.short_description; end - include Byebug::Helpers::FrameHelper -end -class Byebug::ControlProcessor < Byebug::CommandProcessor - def commands; end - def prompt; end -end -module Byebug::Remote -end -class Byebug::Remote::Server - def actual_port; end - def initialize(wait_connection:, &block); end - def start(host, port); end - def wait_connection; end -end -class Byebug::Remote::Client - def connect_at(host, port); end - def initialize(interface); end - def interface; end - def socket; end - def start(host = nil, port = nil); end - def started?; end -end -module Byebug::Printers -end -class Byebug::Printers::Base - def array_of_args(collection, &_block); end - def contents; end - def contents_files; end - def locate(path); end - def parts(path); end - def translate(string, args = nil); end - def type; end -end -class Byebug::Printers::Base::MissedPath < StandardError -end -class Byebug::Printers::Base::MissedArgument < StandardError -end -class Byebug::Printers::Plain < Byebug::Printers::Base - def contents_files; end - def print(path, args = nil); end - def print_collection(path, collection, &block); end - def print_variables(variables, *_unused); end -end -class Byebug::AutoprySetting < Byebug::Setting - def banner; end - def initialize; end - def value; end - def value=(val); end -end -class Byebug::StackOnErrorSetting < Byebug::Setting - def banner; end -end -class Byebug::HistfileSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::WidthSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::SavefileSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::FullpathSetting < Byebug::Setting - def banner; end -end -class Byebug::BasenameSetting < Byebug::Setting - def banner; end -end -class Byebug::ListsizeSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::AutolistSetting < Byebug::Setting - def banner; end - def initialize; end - def value; end - def value=(val); end -end -class Byebug::AutosaveSetting < Byebug::Setting - def banner; end -end -class Byebug::CallstyleSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::PostMortemSetting < Byebug::Setting - def banner; end - def initialize; end - def value; end - def value=(val); end -end -class Byebug::HistsizeSetting < Byebug::Setting - def banner; end - def to_s; end -end -class Byebug::AutoirbSetting < Byebug::Setting - def banner; end - def initialize; end - def value; end - def value=(val); end -end -class Byebug::LinetraceSetting < Byebug::Setting - def banner; end - def value; end - def value=(val); end -end -class Exception - def __bb_context; end -end diff --git a/sorbet/rbi/gems/byebug@11.1.3.rbi b/sorbet/rbi/gems/byebug@11.1.3.rbi new file mode 100644 index 00000000..ab5ca883 --- /dev/null +++ b/sorbet/rbi/gems/byebug@11.1.3.rbi @@ -0,0 +1,3603 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `byebug` gem. +# Please instead update this file by running `bin/tapioca gem byebug`. + +# Main Container for all of Byebug's code +# +# source://byebug-11.1.3/lib/byebug/helpers/reflection.rb:3 +module Byebug + include ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug + + # Debugger's display expressions + # + # source://byebug-11.1.3/lib/byebug/core.rb:31 + def displays; end + + # Debugger's display expressions + # + # source://byebug-11.1.3/lib/byebug/core.rb:31 + def displays=(_arg0); end + + # Configuration file used for startup commands. Default value is .byebugrc + # + # source://byebug-11.1.3/lib/byebug/core.rb:25 + def init_file; end + + # Configuration file used for startup commands. Default value is .byebugrc + # + # source://byebug-11.1.3/lib/byebug/core.rb:25 + def init_file=(_arg0); end + + # Running mode of the debugger. Can be either: + # + # * :attached => Attached to a running program through the `byebug` method. + # * :standalone => Started through `byebug` script. + # * :off => Ignoring any `byebug` method calls. + # + # source://byebug-11.1.3/lib/byebug/core.rb:41 + def mode; end + + # Running mode of the debugger. Can be either: + # + # * :attached => Attached to a running program through the `byebug` method. + # * :standalone => Started through `byebug` script. + # * :off => Ignoring any `byebug` method calls. + # + # source://byebug-11.1.3/lib/byebug/core.rb:41 + def mode=(_arg0); end + + # Runs normal byebug initialization scripts. + # + # Reads and executes the commands from init file (if any) in the current + # working directory. This is only done if the current directory is different + # from your home directory. Thus, you can have more than one init file, one + # generic in your home directory, and another, specific to the program you + # are debugging, in the directory where you invoke byebug. + # + # source://byebug-11.1.3/lib/byebug/core.rb:52 + def run_init_script; end + + private + + def add_catchpoint(_arg0); end + def breakpoints; end + def catchpoints; end + def contexts; end + def current_context; end + def debug_load(*_arg0); end + def lock; end + def post_mortem=(_arg0); end + def post_mortem?; end + def raised_exception; end + + # List of folders to load rc files from + # + # @note Files will be loaded in the order specified here. + # + # source://byebug-11.1.3/lib/byebug/core.rb:102 + def rc_dirs; end + + # Runs a initialization script file + # + # source://byebug-11.1.3/lib/byebug/core.rb:91 + def run_rc_file(rc_file); end + + def start; end + def started?; end + def stop; end + def stoppable?; end + def thread_context(_arg0); end + def tracing=(_arg0); end + def tracing?; end + def unlock; end + def verbose=(_arg0); end + def verbose?; end + + class << self + # The actual port that the control server is started at + # + # source://byebug-11.1.3/lib/byebug/remote.rb:25 + def actual_control_port; end + + # The actual port that the server is started at + # + # source://byebug-11.1.3/lib/byebug/remote.rb:20 + def actual_port; end + + def add_catchpoint(_arg0); end + + # Starts byebug, and stops at the first line of user's code. + # + # source://byebug-11.1.3/lib/byebug/attacher.rb:10 + def attach; end + + def breakpoints; end + def catchpoints; end + def contexts; end + def current_context; end + def debug_load(*_arg0); end + + # Saves information about the unhandled exception and gives a byebug + # prompt back to the user before program termination. + # + # source://byebug-11.1.3/lib/byebug/core.rb:76 + def handle_post_mortem; end + + # Interrupts the current thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:32 + def interrupt; end + + # source://byebug-11.1.3/lib/byebug/core.rb:61 + def load_settings; end + + def lock; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:59 + def parse_host_and_port(host_port_spec); end + + def post_mortem=(_arg0); end + def post_mortem?; end + def raised_exception; end + + # source://byebug-11.1.3/lib/byebug/attacher.rb:21 + def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end + + def start; end + + # Connects to the remote byebug + # + # source://byebug-11.1.3/lib/byebug/remote.rb:55 + def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end + + # Starts the remote server control thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:48 + def start_control(host = T.unsafe(nil), port = T.unsafe(nil)); end + + # Starts the remote server main thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:39 + def start_server(host = T.unsafe(nil), port = T.unsafe(nil)); end + + def started?; end + def stop; end + def stoppable?; end + def thread_context(_arg0); end + def tracing=(_arg0); end + def tracing?; end + def unlock; end + def verbose=(_arg0); end + def verbose?; end + + # If in remote mode, wait for the remote connection + # + # source://byebug-11.1.3/lib/byebug/remote.rb:17 + def wait_connection; end + + # If in remote mode, wait for the remote connection + # + # source://byebug-11.1.3/lib/byebug/remote.rb:17 + def wait_connection=(_arg0); end + + private + + # source://byebug-11.1.3/lib/byebug/remote.rb:66 + def client; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:76 + def control; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:70 + def server; end + end +end + +# Setting for automatically invoking IRB on every stop. +# +# source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:10 +class Byebug::AutoirbSetting < ::Byebug::Setting + # @return [AutoirbSetting] a new instance of AutoirbSetting + # + # source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:13 + def initialize; end + + # source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:17 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:25 + def value; end + + # source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:21 + def value=(val); end +end + +# source://byebug-11.1.3/lib/byebug/settings/autoirb.rb:11 +Byebug::AutoirbSetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Setting for automatically listing source code on every stop. +# +# source://byebug-11.1.3/lib/byebug/settings/autolist.rb:10 +class Byebug::AutolistSetting < ::Byebug::Setting + # @return [AutolistSetting] a new instance of AutolistSetting + # + # source://byebug-11.1.3/lib/byebug/settings/autolist.rb:13 + def initialize; end + + # source://byebug-11.1.3/lib/byebug/settings/autolist.rb:17 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/autolist.rb:25 + def value; end + + # source://byebug-11.1.3/lib/byebug/settings/autolist.rb:21 + def value=(val); end +end + +# source://byebug-11.1.3/lib/byebug/settings/autolist.rb:11 +Byebug::AutolistSetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Setting for automatically invoking Pry on every stop. +# +# source://byebug-11.1.3/lib/byebug/settings/autopry.rb:10 +class Byebug::AutoprySetting < ::Byebug::Setting + # @return [AutoprySetting] a new instance of AutoprySetting + # + # source://byebug-11.1.3/lib/byebug/settings/autopry.rb:13 + def initialize; end + + # source://byebug-11.1.3/lib/byebug/settings/autopry.rb:17 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/autopry.rb:25 + def value; end + + # source://byebug-11.1.3/lib/byebug/settings/autopry.rb:21 + def value=(val); end +end + +# source://byebug-11.1.3/lib/byebug/settings/autopry.rb:11 +Byebug::AutoprySetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Setting for automatically saving previously entered commands to history +# when exiting the debugger. +# +# source://byebug-11.1.3/lib/byebug/settings/autosave.rb:10 +class Byebug::AutosaveSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/autosave.rb:13 + def banner; end +end + +# source://byebug-11.1.3/lib/byebug/settings/autosave.rb:11 +Byebug::AutosaveSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass) + +# Command to display short paths in file names. +# +# For example, when displaying source code information. +# +# source://byebug-11.1.3/lib/byebug/settings/basename.rb:11 +class Byebug::BasenameSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/basename.rb:12 + def banner; end +end + +# Implements breakpoint functionality +# +# source://byebug-11.1.3/lib/byebug/commands/break.rb:13 +class Byebug::BreakCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:40 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:83 + def add_line_breakpoint(file, line); end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:54 + def line_breakpoint(location); end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:65 + def method_breakpoint(location); end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:74 + def target_object(str); end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:104 + def valid_breakpoints_for(path, line); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/break.rb:24 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:20 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/break.rb:36 + def short_description; end + end +end + +# Implements breakpoints +# +# source://byebug-11.1.3/lib/byebug/breakpoint.rb:7 +class Byebug::Breakpoint + def initialize(_arg0, _arg1, _arg2); end + + def enabled=(_arg0); end + def enabled?; end + def expr; end + def expr=(_arg0); end + def hit_condition; end + def hit_condition=(_arg0); end + def hit_count; end + def hit_value; end + def hit_value=(_arg0); end + def id; end + + # Prints all information associated to the breakpoint + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:105 + def inspect; end + + def pos; end + def source; end + + class << self + # Adds a new breakpoint + # + # @param file [String] + # @param line [Fixnum] + # @param expr [String] + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:29 + def add(file, line, expr = T.unsafe(nil)); end + + # First breakpoint, in order of creation + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:11 + def first; end + + # Last breakpoint, in order of creation + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:18 + def last; end + + # True if there's no breakpoints + # + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:98 + def none?; end + + # Returns true if a breakpoint could be set in line number +lineno+ in file + # name +filename. + # + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:91 + def potential_line?(filename, lineno); end + + # Returns an array of line numbers in file named +filename+ where + # breakpoints could be set. The list will contain an entry for each + # distinct line event call so it is possible (and possibly useful) for a + # line number appear more than once. + # + # @param filename [String] File name to inspect for possible breakpoints + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:52 + def potential_lines(filename); end + + # Removes a breakpoint + # + # @param id [integer] breakpoint number + # + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:40 + def remove(id); end + + private + + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:63 + def potential_lines_with_trace_points(iseq, lines); end + + # source://byebug-11.1.3/lib/byebug/breakpoint.rb:74 + def potential_lines_without_trace_points(iseq, lines); end + end +end + +# Setting to customize the verbosity level for stack frames. +# +# source://byebug-11.1.3/lib/byebug/settings/callstyle.rb:9 +class Byebug::CallstyleSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/callstyle.rb:12 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/callstyle.rb:16 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/callstyle.rb:10 +Byebug::CallstyleSetting::DEFAULT = T.let(T.unsafe(nil), String) + +# Implements exception catching. +# +# Enables the user to catch unhandled assertion when they happen. +# +# source://byebug-11.1.3/lib/byebug/commands/catch.rb:12 +class Byebug::CatchCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:38 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:57 + def add(exception); end + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:64 + def clear; end + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:68 + def info; end + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:50 + def remove(exception); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:21 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:17 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/catch.rb:34 + def short_description; end + end +end + +# Parent class of all byebug commands. +# +# Subclass it and name the subclass ending with the word Command to implement +# your own custom command. +# +# class MyCustomCommand < Command +# def self.regexp +# /custom_regexp/ +# end +# +# def self.description +# "Custom long desc" +# end +# +# def.short_description +# "Custom short desc" +# end +# +# def execute +# # My command's implementation +# end +# end +# +# @example Define a custom command +# +# source://byebug-11.1.3/lib/byebug/command.rb:33 +class Byebug::Command + extend ::Forwardable + extend ::Byebug::Helpers::StringHelper + + # @return [Command] a new instance of Command + # + # source://byebug-11.1.3/lib/byebug/command.rb:38 + def initialize(processor, input = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/command.rb:51 + def arguments; end + + # source://RUBY_ROOT/forwardable.rb:226 + def confirm(*args, &block); end + + # source://byebug-11.1.3/lib/byebug/command.rb:43 + def context; end + + # source://RUBY_ROOT/forwardable.rb:226 + def errmsg(*args, &block); end + + # source://byebug-11.1.3/lib/byebug/command.rb:47 + def frame; end + + # source://RUBY_ROOT/forwardable.rb:226 + def help(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def match(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pr(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prc(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print(*args, &block); end + + # Returns the value of attribute processor. + # + # source://byebug-11.1.3/lib/byebug/command.rb:36 + def processor; end + + # source://RUBY_ROOT/forwardable.rb:226 + def prv(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def puts(*args, &block); end + + class << self + # Special methods to allow command filtering in processors + # + # source://byebug-11.1.3/lib/byebug/command.rb:69 + def allow_in_control; end + + # Special methods to allow command filtering in processors + # + # source://byebug-11.1.3/lib/byebug/command.rb:69 + def allow_in_control=(_arg0); end + + # Special methods to allow command filtering in processors + # + # source://byebug-11.1.3/lib/byebug/command.rb:69 + def allow_in_post_mortem; end + + # Special methods to allow command filtering in processors + # + # source://byebug-11.1.3/lib/byebug/command.rb:69 + def allow_in_post_mortem=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/command.rb:73 + def always_run; end + + # Sets the attribute always_run + # + # @param value the value to set the attribute always_run to. + # + # source://byebug-11.1.3/lib/byebug/command.rb:71 + def always_run=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/command.rb:88 + def columnize(width); end + + # Default help text for a command. + # + # source://byebug-11.1.3/lib/byebug/command.rb:99 + def help; end + + # Command's regexp match against an input + # + # source://byebug-11.1.3/lib/byebug/command.rb:106 + def match(input); end + + # Name of the command, as executed by the user. + # + # source://byebug-11.1.3/lib/byebug/command.rb:80 + def to_s; end + end +end + +# Holds an array of subcommands for a command +# +# source://byebug-11.1.3/lib/byebug/command_list.rb:9 +class Byebug::CommandList + include ::Enumerable + + # @return [CommandList] a new instance of CommandList + # + # source://byebug-11.1.3/lib/byebug/command_list.rb:12 + def initialize(commands); end + + # source://byebug-11.1.3/lib/byebug/command_list.rb:20 + def each; end + + # source://byebug-11.1.3/lib/byebug/command_list.rb:16 + def match(input); end + + # source://byebug-11.1.3/lib/byebug/command_list.rb:24 + def to_s; end + + private + + # source://byebug-11.1.3/lib/byebug/command_list.rb:30 + def width; end +end + +# Custom exception exception to signal "command not found" errors +# +# source://byebug-11.1.3/lib/byebug/errors.rb:7 +class Byebug::CommandNotFound < ::NoMethodError + # @return [CommandNotFound] a new instance of CommandNotFound + # + # source://byebug-11.1.3/lib/byebug/errors.rb:8 + def initialize(input, parent = T.unsafe(nil)); end + + private + + # source://byebug-11.1.3/lib/byebug/errors.rb:25 + def build_cmd(*args); end + + # source://byebug-11.1.3/lib/byebug/errors.rb:21 + def help; end + + # source://byebug-11.1.3/lib/byebug/errors.rb:17 + def name; end +end + +# Processes commands in regular mode. +# +# You can override this class to create your own command processor that, for +# example, whitelists only certain commands to be executed. +# +# @see PostMortemProcessor for a example +# +# source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:17 +class Byebug::CommandProcessor + include ::Byebug::Helpers::EvalHelper + extend ::Forwardable + + # @return [CommandProcessor] a new instance of CommandProcessor + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:23 + def initialize(context, interface = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:64 + def at_breakpoint(brkpt); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:70 + def at_catchpoint(exception); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:80 + def at_end; end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:54 + def at_line; end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:74 + def at_return(return_value); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:58 + def at_tracing; end + + # Available commands + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:50 + def command_list; end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def confirm(*args, &block); end + + # Returns the value of attribute context. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:21 + def context; end + + # source://RUBY_ROOT/forwardable.rb:226 + def errmsg(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def frame(*args, &block); end + + # Returns the value of attribute interface. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:21 + def interface; end + + # source://RUBY_ROOT/forwardable.rb:226 + def pr(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prc(*args, &block); end + + # Returns the value of attribute prev_line. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:20 + def prev_line; end + + # Sets the attribute prev_line + # + # @param value the value to set the attribute prev_line to. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:20 + def prev_line=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:31 + def printer; end + + # Let the execution continue + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:87 + def proceed!; end + + # Handle byebug commands. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:94 + def process_commands; end + + # source://RUBY_ROOT/forwardable.rb:226 + def prv(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def puts(*args, &block); end + + protected + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:119 + def after_repl; end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:111 + def before_repl; end + + # Prompt shown before reading a command. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:107 + def prompt; end + + # Main byebug's REPL + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:126 + def repl; end + + private + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:139 + def auto_cmds_for(run_level); end + + # Run permanent commands. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:146 + def run_auto_cmds(run_level); end + + # Executes the received input + # + # Instantiates a command matching the input and runs it. If a matching + # command is not found, it evaluates the unknown input. + # + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:158 + def run_cmd(input); end + + # source://byebug-11.1.3/lib/byebug/processors/command_processor.rb:167 + def safely; end +end + +# Implements conditions on breakpoints. +# +# Adds the ability to stop on breakpoints only under certain conditions. +# +# source://byebug-11.1.3/lib/byebug/commands/condition.rb:12 +class Byebug::ConditionCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/condition.rb:38 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/condition.rb:21 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/condition.rb:17 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/condition.rb:34 + def short_description; end + end +end + +# Mantains context information for the debugger and it's the main +# communication point between the library and the C-extension through the +# at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks +# +# source://byebug-11.1.3/lib/byebug/context.rb:14 +class Byebug::Context + include ::Byebug::Helpers::FileHelper + extend ::Byebug::Helpers::PathHelper + extend ::Forwardable + + # Breakpoint handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:113 + def at_breakpoint(breakpoint); end + + # Catchpoint handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:120 + def at_catchpoint(exception); end + + # End of class definition handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:136 + def at_end; end + + # Line handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:94 + def at_line; end + + # Return handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:127 + def at_return(return_value); end + + # Tracing handler + # + # source://byebug-11.1.3/lib/byebug/context.rb:104 + def at_tracing; end + + def backtrace; end + def dead?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def file(*args, &block); end + + # Reader for the current frame + # + # source://byebug-11.1.3/lib/byebug/context.rb:46 + def frame; end + + # Writer for the current frame + # + # source://byebug-11.1.3/lib/byebug/context.rb:53 + def frame=(pos); end + + def frame_binding(*_arg0); end + def frame_class(*_arg0); end + def frame_file(*_arg0); end + def frame_line(*_arg0); end + def frame_method(*_arg0); end + def frame_self(*_arg0); end + + # Current file, line and source code information + # + # source://byebug-11.1.3/lib/byebug/context.rb:70 + def full_location; end + + def ignored?; end + + # source://byebug-11.1.3/lib/byebug/context.rb:87 + def interrupt; end + + # source://RUBY_ROOT/forwardable.rb:226 + def line(*args, &block); end + + # Current file & line information + # + # source://byebug-11.1.3/lib/byebug/context.rb:63 + def location; end + + def resume; end + + # Context's stack size + # + # source://byebug-11.1.3/lib/byebug/context.rb:79 + def stack_size; end + + def step_into(*_arg0); end + def step_out(*_arg0); end + def step_over(*_arg0); end + def stop_reason; end + def suspend; end + def suspended?; end + def switch; end + def thnum; end + def thread; end + def tracing; end + def tracing=(_arg0); end + + private + + # Tells whether a file is ignored by the debugger. + # + # @param path [String] filename to be checked. + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/context.rb:153 + def ignored_file?(path); end + + # source://byebug-11.1.3/lib/byebug/context.rb:144 + def processor; end + + class << self + # List of files byebug will ignore while debugging + # + # source://byebug-11.1.3/lib/byebug/context.rb:25 + def ignored_files; end + + # Sets the attribute ignored_files + # + # @param value the value to set the attribute ignored_files to. + # + # source://byebug-11.1.3/lib/byebug/context.rb:20 + def ignored_files=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/context.rb:32 + def interface; end + + # Sets the attribute interface + # + # @param value the value to set the attribute interface to. + # + # source://byebug-11.1.3/lib/byebug/context.rb:30 + def interface=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/context.rb:38 + def processor; end + + # Sets the attribute processor + # + # @param value the value to set the attribute processor to. + # + # source://byebug-11.1.3/lib/byebug/context.rb:36 + def processor=(_arg0); end + end +end + +# Implements the continue command. +# +# Allows the user to continue execution until the next stopping point, a +# specific line number or until program termination. +# +# source://byebug-11.1.3/lib/byebug/commands/continue.rb:13 +class Byebug::ContinueCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:37 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:64 + def modifier; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:60 + def unconditionally?; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:56 + def until_line?; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/continue.rb:33 + def short_description; end + end +end + +# Processes commands when there's not program running +# +# source://byebug-11.1.3/lib/byebug/processors/control_processor.rb:12 +class Byebug::ControlProcessor < ::Byebug::CommandProcessor + # Available commands + # + # source://byebug-11.1.3/lib/byebug/processors/control_processor.rb:13 + def commands; end + + # Prompt shown before reading a command. + # + # source://byebug-11.1.3/lib/byebug/processors/control_processor.rb:20 + def prompt; end +end + +# Spawns a subdebugger and evaluates the given expression +# +# source://byebug-11.1.3/lib/byebug/commands/debug.rb:10 +class Byebug::DebugCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/commands/debug.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/debug.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/debug.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/debug.rb:28 + def short_description; end + end +end + +class Byebug::DebugThread < ::Thread + class << self + def inherited; end + end +end + +# Implements breakpoint deletion. +# +# source://byebug-11.1.3/lib/byebug/commands/delete.rb:10 +class Byebug::DeleteCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/delete.rb:35 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/delete.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/delete.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/delete.rb:31 + def short_description; end + end +end + +# Disabling custom display expressions or breakpoints. +# +# source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:12 +class Byebug::DisableCommand < ::Byebug::Command + include ::Byebug::Subcommands + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Subcommands::ClassMethods + + class << self + # source://byebug-11.1.3/lib/byebug/commands/disable.rb:21 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/disable.rb:17 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/disable.rb:29 + def short_description; end + end +end + +# Disables all or specific breakpoints +# +# source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:13 +class Byebug::DisableCommand::BreakpointsCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + include ::Byebug::Helpers::ToggleHelper + + # source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:37 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/disable/breakpoints.rb:33 + def short_description; end + end +end + +# Enables all or specific displays +# +# source://byebug-11.1.3/lib/byebug/commands/disable/display.rb:13 +class Byebug::DisableCommand::DisplayCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + include ::Byebug::Helpers::ToggleHelper + + # source://byebug-11.1.3/lib/byebug/commands/disable/display.rb:38 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/disable/display.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/disable/display.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/disable/display.rb:34 + def short_description; end + end +end + +# Custom expressions to be displayed every time the debugger stops. +# +# source://byebug-11.1.3/lib/byebug/commands/display.rb:10 +class Byebug::DisplayCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:35 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:44 + def display_expression(exp); end + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:60 + def eval_expr(expression); end + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:50 + def print_display_expressions; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/display.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/display.rb:31 + def short_description; end + end +end + +# Move the current frame down in the backtrace. +# +# source://byebug-11.1.3/lib/byebug/commands/down.rb:12 +class Byebug::DownCommand < ::Byebug::Command + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/down.rb:36 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/down.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/down.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/down.rb:32 + def short_description; end + end +end + +# Edit a file from byebug's prompt. +# +# source://byebug-11.1.3/lib/byebug/commands/edit.rb:9 +class Byebug::EditCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:33 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:65 + def edit_error(type, file); end + + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:61 + def editor; end + + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:45 + def location(matched); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/edit.rb:29 + def short_description; end + end +end + +# Enabling custom display expressions or breakpoints. +# +# source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:12 +class Byebug::EnableCommand < ::Byebug::Command + include ::Byebug::Subcommands + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Subcommands::ClassMethods + + class << self + # source://byebug-11.1.3/lib/byebug/commands/enable.rb:21 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/enable.rb:17 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/enable.rb:29 + def short_description; end + end +end + +# Enables all or specific breakpoints +# +# source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:13 +class Byebug::EnableCommand::BreakpointsCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + include ::Byebug::Helpers::ToggleHelper + + # source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:37 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/enable/breakpoints.rb:33 + def short_description; end + end +end + +# Enables all or specific displays +# +# source://byebug-11.1.3/lib/byebug/commands/enable/display.rb:13 +class Byebug::EnableCommand::DisplayCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + include ::Byebug::Helpers::ToggleHelper + + # source://byebug-11.1.3/lib/byebug/commands/enable/display.rb:38 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/enable/display.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/enable/display.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/enable/display.rb:34 + def short_description; end + end +end + +# Implements the finish functionality. +# +# Allows the user to continue execution until certain frames are finished. +# +# source://byebug-11.1.3/lib/byebug/commands/finish.rb:12 +class Byebug::FinishCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/finish.rb:37 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/finish.rb:53 + def max_frames; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/finish.rb:21 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/finish.rb:17 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/finish.rb:33 + def short_description; end + end +end + +# Represents a frame in the stack trace +# +# source://byebug-11.1.3/lib/byebug/frame.rb:9 +class Byebug::Frame + include ::Byebug::Helpers::FileHelper + + # @return [Frame] a new instance of Frame + # + # source://byebug-11.1.3/lib/byebug/frame.rb:14 + def initialize(context, pos); end + + # source://byebug-11.1.3/lib/byebug/frame.rb:31 + def _binding; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:35 + def _class; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:39 + def _method; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:27 + def _self; end + + # Gets current method arguments for the frame. + # + # source://byebug-11.1.3/lib/byebug/frame.rb:62 + def args; end + + # Checks whether the frame is a c-frame + # + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/frame.rb:141 + def c_frame?; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/frame.rb:43 + def current?; end + + # Builds a string containing all available args in the frame number, in a + # verbose or non verbose way according to the value of the +callstyle+ + # setting + # + # source://byebug-11.1.3/lib/byebug/frame.rb:89 + def deco_args; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:76 + def deco_block; end + + # Builds a formatted string containing information about current method call + # + # source://byebug-11.1.3/lib/byebug/frame.rb:106 + def deco_call; end + + # Returns the current class in the frame or an empty string if the current + # +callstyle+ setting is 'short' + # + # source://byebug-11.1.3/lib/byebug/frame.rb:72 + def deco_class; end + + # Formatted filename in frame + # + # source://byebug-11.1.3/lib/byebug/frame.rb:113 + def deco_file; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:80 + def deco_method; end + + # Properly formatted frame number of frame + # + # source://byebug-11.1.3/lib/byebug/frame.rb:120 + def deco_pos; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:19 + def file; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:23 + def line; end + + # Gets local variables for the frame. + # + # source://byebug-11.1.3/lib/byebug/frame.rb:50 + def locals; end + + # Formatted mark for the frame. + # + # --> marks the current frame + # ͱ-- marks c-frames + # marks regular frames + # + # source://byebug-11.1.3/lib/byebug/frame.rb:131 + def mark; end + + # Returns the value of attribute pos. + # + # source://byebug-11.1.3/lib/byebug/frame.rb:12 + def pos; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:145 + def to_hash; end + + private + + # source://byebug-11.1.3/lib/byebug/frame.rb:158 + def c_args; end + + # source://byebug-11.1.3/lib/byebug/frame.rb:178 + def prefix_and_default(arg_type); end + + # source://byebug-11.1.3/lib/byebug/frame.rb:164 + def ruby_args; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/frame.rb:174 + def use_short_style?(arg); end +end + +# Move to specific frames in the backtrace. +# +# source://byebug-11.1.3/lib/byebug/commands/frame.rb:12 +class Byebug::FrameCommand < ::Byebug::Command + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/frame.rb:46 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/frame.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/frame.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/frame.rb:42 + def short_description; end + end +end + +# Setting to display full paths in backtraces. +# +# source://byebug-11.1.3/lib/byebug/settings/fullpath.rb:9 +class Byebug::FullpathSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/fullpath.rb:12 + def banner; end +end + +# source://byebug-11.1.3/lib/byebug/settings/fullpath.rb:10 +Byebug::FullpathSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass) + +# Ask for help from byebug's prompt. +# +# source://byebug-11.1.3/lib/byebug/commands/help.rb:10 +class Byebug::HelpCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/help.rb:34 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/help.rb:54 + def command; end + + # @raise [CommandNotFound] + # + # source://byebug-11.1.3/lib/byebug/commands/help.rb:48 + def help_for(input, cmd); end + + # source://byebug-11.1.3/lib/byebug/commands/help.rb:44 + def help_for_all; end + + # source://byebug-11.1.3/lib/byebug/commands/help.rb:58 + def subcommand; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/help.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/help.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/help.rb:30 + def short_description; end + end +end + +# source://byebug-11.1.3/lib/byebug/helpers/reflection.rb:4 +module Byebug::Helpers; end + +# Utilities for interaction with executables +# +# source://byebug-11.1.3/lib/byebug/helpers/bin.rb:8 +module Byebug::Helpers::BinHelper + # source://byebug-11.1.3/lib/byebug/helpers/bin.rb:38 + def executable_file_extensions; end + + # source://byebug-11.1.3/lib/byebug/helpers/bin.rb:24 + def find_executable(path, cmd); end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/helpers/bin.rb:42 + def real_executable?(file); end + + # source://byebug-11.1.3/lib/byebug/helpers/bin.rb:34 + def search_paths; end + + # Cross-platform way of finding an executable in the $PATH. + # Adapted from: https://gist.github.com/steakknife/88b6c3837a5e90a08296 + # + # source://byebug-11.1.3/lib/byebug/helpers/bin.rb:13 + def which(cmd); end +end + +# Utilities to assist evaluation of code strings +# +# source://byebug-11.1.3/lib/byebug/helpers/eval.rb:8 +module Byebug::Helpers::EvalHelper + # Evaluates a string containing Ruby code in a specific binding, + # handling the errors at an error level. + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:46 + def error_eval(str, binding = T.unsafe(nil)); end + + # Evaluates an +expression+ that might use or defer execution to threads + # other than the current one. + # + # "frozen" so that nothing gets run. So we need to unlock threads prior + # to evaluation or we will run into a deadlock. + # + # @note This is necessary because when in byebug's prompt, every thread is + # @param expression [String] Expression to evaluate + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:30 + def multiple_thread_eval(expression); end + + # Evaluates an +expression+ in a separate thread. + # + # @param expression [String] Expression to evaluate + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:14 + def separate_thread_eval(expression); end + + # Evaluates a string containing Ruby code in a specific binding, + # returning nil in an error happens. + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:38 + def silent_eval(str, binding = T.unsafe(nil)); end + + # Evaluates a string containing Ruby code in a specific binding, + # handling the errors at a warning level. + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:54 + def warning_eval(str, binding = T.unsafe(nil)); end + + private + + # Run block temporarily ignoring all TracePoint events. + # + # Used to evaluate stuff within Byebug's prompt. Otherwise, any code + # creating new threads won't be properly evaluated because new threads + # will get blocked by byebug's main thread. + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:91 + def allowing_other_threads; end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:72 + def error_msg(exception); end + + # Runs the given block in a new thread, waits for it to finish and + # returns the new thread's result. + # + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:105 + def in_new_thread; end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:66 + def msg(exception); end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:60 + def safe_eval(str, binding); end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:113 + def safe_inspect(var); end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:119 + def safe_to_s(var); end + + # source://byebug-11.1.3/lib/byebug/helpers/eval.rb:80 + def warning_msg(exception); end +end + +# Utilities for interaction with files +# +# source://byebug-11.1.3/lib/byebug/helpers/file.rb:8 +module Byebug::Helpers::FileHelper + # Reads line number +lineno+ from file named +filename+ + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:19 + def get_line(filename, lineno); end + + # Reads lines of source file +filename+ into an array + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:12 + def get_lines(filename); end + + # Returns the number of lines in file +filename+ in a portable, + # one-line-at-a-time way. + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:30 + def n_lines(filename); end + + # Regularize file name. + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:37 + def normalize(filename); end + + # A short version of a long path + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:48 + def shortpath(fullpath); end + + # True for special files like -e, false otherwise + # + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/helpers/file.rb:58 + def virtual_file?(name); end +end + +# Utilities to assist frame navigation +# +# source://byebug-11.1.3/lib/byebug/helpers/frame.rb:8 +module Byebug::Helpers::FrameHelper + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:16 + def jump_frames(steps); end + + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:9 + def switch_to_frame(frame); end + + private + + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:22 + def adjust_frame(new_frame); end + + # @param step [Integer] A positive or negative integer + # @return [Integer] +1 if step is positive / -1 if negative + # + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:60 + def direction(step); end + + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:51 + def frame_err(msg); end + + # Convert a possibly negative index to a positive index from the start + # of the callstack. -1 is the last position in the stack and so on. + # + # @param i [Integer] Integer to be converted in a proper positive index. + # + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:70 + def index_from_start(index); end + + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:30 + def navigate_to_frame(jump_no); end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/helpers/frame.rb:47 + def out_of_bounds?(pos); end +end + +# Utilities to assist command parsing +# +# source://byebug-11.1.3/lib/byebug/helpers/parse.rb:8 +module Byebug::Helpers::ParseHelper + # Parses +str+ of command +cmd+ as an integer between +min+ and +max+. + # + # If either +min+ or +max+ is nil, that value has no bound. + # + # purpose. + # + # @todo Remove the `cmd` parameter. It has nothing to do with the method's + # + # source://byebug-11.1.3/lib/byebug/helpers/parse.rb:17 + def get_int(str, cmd, min = T.unsafe(nil), max = T.unsafe(nil)); end + + # @return +str+ as an integer or 1 if +str+ is empty. + # + # source://byebug-11.1.3/lib/byebug/helpers/parse.rb:51 + def parse_steps(str, cmd); end + + # @return [Boolean] true if code is syntactically correct for Ruby, false otherwise + # + # source://byebug-11.1.3/lib/byebug/helpers/parse.rb:35 + def syntax_valid?(code); end + + private + + # Temporarily disable output to $stderr + # + # source://byebug-11.1.3/lib/byebug/helpers/parse.rb:65 + def without_stderr; end +end + +# Utilities for managing gem paths +# +# source://byebug-11.1.3/lib/byebug/helpers/path.rb:8 +module Byebug::Helpers::PathHelper + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:29 + def all_files; end + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:9 + def bin_file; end + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:25 + def gem_files; end + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:17 + def lib_files; end + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:13 + def root_path; end + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:21 + def test_files; end + + private + + # source://byebug-11.1.3/lib/byebug/helpers/path.rb:35 + def glob_for(dir); end +end + +# Reflection utilitie +# +# source://byebug-11.1.3/lib/byebug/helpers/reflection.rb:8 +module Byebug::Helpers::ReflectionHelper + # List of "command" classes in the including module + # + # source://byebug-11.1.3/lib/byebug/helpers/reflection.rb:12 + def commands; end +end + +# Utilities for interaction with strings +# +# source://byebug-11.1.3/lib/byebug/helpers/string.rb:8 +module Byebug::Helpers::StringHelper + # Converts +str+ from an_underscored-or-dasherized_string to + # ACamelizedString. + # + # source://byebug-11.1.3/lib/byebug/helpers/string.rb:13 + def camelize(str); end + + # Removes a number of leading whitespace for each input line. + # + # source://byebug-11.1.3/lib/byebug/helpers/string.rb:28 + def deindent(str, leading_spaces: T.unsafe(nil)); end + + # Improves indentation and spacing in +str+ for readability in Byebug's + # command prompt. + # + # source://byebug-11.1.3/lib/byebug/helpers/string.rb:21 + def prettify(str); end +end + +# Utilities for thread subcommands +# +# source://byebug-11.1.3/lib/byebug/helpers/thread.rb:8 +module Byebug::Helpers::ThreadHelper + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:30 + def context_from_thread(thnum); end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:26 + def current_thread?(ctx); end + + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:9 + def display_context(ctx); end + + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:13 + def thread_arguments(ctx); end + + private + + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:62 + def debug_flag(ctx); end + + # @todo Check whether it is Byebug.current_context or context + # + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:47 + def location(ctx); end + + # source://byebug-11.1.3/lib/byebug/helpers/thread.rb:56 + def status_flag(ctx); end +end + +# Utilities to assist breakpoint/display enabling/disabling. +# +# source://byebug-11.1.3/lib/byebug/helpers/toggle.rb:10 +module Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/helpers/toggle.rb:13 + def enable_disable_breakpoints(is_enable, args); end + + # source://byebug-11.1.3/lib/byebug/helpers/toggle.rb:26 + def enable_disable_display(is_enable, args); end + + private + + # source://byebug-11.1.3/lib/byebug/helpers/toggle.rb:57 + def n_displays; end + + # source://byebug-11.1.3/lib/byebug/helpers/toggle.rb:41 + def select_breakpoints(is_enable, args); end +end + +# Utilities for variable subcommands +# +# source://byebug-11.1.3/lib/byebug/helpers/var.rb:10 +module Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/helpers/var.rb:42 + def var_args; end + + # source://byebug-11.1.3/lib/byebug/helpers/var.rb:21 + def var_global; end + + # source://byebug-11.1.3/lib/byebug/helpers/var.rb:29 + def var_instance(str); end + + # source://byebug-11.1.3/lib/byebug/helpers/var.rb:13 + def var_list(ary, binding = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/helpers/var.rb:35 + def var_local; end +end + +# Setting to customize the file where byebug's history is saved. +# +# source://byebug-11.1.3/lib/byebug/settings/histfile.rb:9 +class Byebug::HistfileSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/histfile.rb:12 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/histfile.rb:16 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/histfile.rb:10 +Byebug::HistfileSetting::DEFAULT = T.let(T.unsafe(nil), String) + +# Handles byebug's history of commands. +# +# source://byebug-11.1.3/lib/byebug/history.rb:19 +class Byebug::History + # @return [History] a new instance of History + # + # source://byebug-11.1.3/lib/byebug/history.rb:22 + def initialize; end + + # Array holding the list of commands in history + # + # source://byebug-11.1.3/lib/byebug/history.rb:29 + def buffer; end + + # Discards history. + # + # source://byebug-11.1.3/lib/byebug/history.rb:58 + def clear; end + + # Max number of commands to be displayed when no size has been specified. + # + # Never more than Setting[:histsize]. + # + # source://byebug-11.1.3/lib/byebug/history.rb:105 + def default_max_size; end + + # Whether a specific command should not be stored in history. + # + # For now, empty lines and consecutive duplicates. + # + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/history.rb:123 + def ignore?(buf); end + + # Array of ids of the last +number+ commands. + # + # source://byebug-11.1.3/lib/byebug/history.rb:96 + def last_ids(number); end + + # Removes a command from Readline's history. + # + # source://byebug-11.1.3/lib/byebug/history.rb:75 + def pop; end + + # Adds a new command to Readline's history. + # + # source://byebug-11.1.3/lib/byebug/history.rb:65 + def push(cmd); end + + # Restores history from disk. + # + # source://byebug-11.1.3/lib/byebug/history.rb:36 + def restore; end + + # Saves history to disk. + # + # source://byebug-11.1.3/lib/byebug/history.rb:45 + def save; end + + # Returns the value of attribute size. + # + # source://byebug-11.1.3/lib/byebug/history.rb:20 + def size; end + + # Sets the attribute size + # + # @param value the value to set the attribute size to. + # + # source://byebug-11.1.3/lib/byebug/history.rb:20 + def size=(_arg0); end + + # Max number of commands to be displayed when a size has been specified. + # + # The only bound here is not showing more items than available. + # + # source://byebug-11.1.3/lib/byebug/history.rb:114 + def specific_max_size(number); end + + # Prints the requested numbers of history entries. + # + # source://byebug-11.1.3/lib/byebug/history.rb:83 + def to_s(n_cmds); end +end + +# Show history of byebug commands. +# +# source://byebug-11.1.3/lib/byebug/commands/history.rb:10 +class Byebug::HistoryCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/history.rb:31 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/history.rb:19 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/history.rb:15 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/history.rb:27 + def short_description; end + end +end + +# Setting to customize the number of byebug commands to be saved in history. +# +# source://byebug-11.1.3/lib/byebug/settings/histsize.rb:9 +class Byebug::HistsizeSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/histsize.rb:12 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/histsize.rb:16 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/histsize.rb:10 +Byebug::HistsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Reopens the +info+ command to define the +line+ subcommand +# +# source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:10 +class Byebug::InfoCommand < ::Byebug::Command + include ::Byebug::Subcommands + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Subcommands::ClassMethods + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info.rb:25 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info.rb:21 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info.rb:33 + def short_description; end + end +end + +# Information about current breakpoints +# +# source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:11 +class Byebug::InfoCommand::BreakpointsCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:30 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:47 + def info_breakpoint(brkpt); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info/breakpoints.rb:26 + def short_description; end + end +end + +# Information about display expressions +# +# source://byebug-11.1.3/lib/byebug/commands/info/display.rb:11 +class Byebug::InfoCommand::DisplayCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/info/display.rb:30 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info/display.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info/display.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info/display.rb:26 + def short_description; end + end +end + +# Information about a particular source file +# +# source://byebug-11.1.3/lib/byebug/commands/info/file.rb:13 +class Byebug::InfoCommand::FileCommand < ::Byebug::Command + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::StringHelper + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:38 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:55 + def info_file_basic(file); end + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:63 + def info_file_breakpoints(file); end + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:70 + def info_file_mtime(file); end + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:74 + def info_file_sha1(file); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:23 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:19 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info/file.rb:34 + def short_description; end + end +end + +# Information about current location +# +# source://byebug-11.1.3/lib/byebug/commands/info/line.rb:11 +class Byebug::InfoCommand::LineCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/info/line.rb:30 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info/line.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info/line.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info/line.rb:26 + def short_description; end + end +end + +# Information about arguments of the current method/block +# +# source://byebug-11.1.3/lib/byebug/commands/info/program.rb:11 +class Byebug::InfoCommand::ProgramCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/info/program.rb:30 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/info/program.rb:37 + def format_stop_reason(stop_reason); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/info/program.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/info/program.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/info/program.rb:26 + def short_description; end + end +end + +# Main Interface class +# +# Contains common functionality to all implemented interfaces. +# +# source://byebug-11.1.3/lib/byebug/interface.rb:16 +class Byebug::Interface + include ::Byebug::Helpers::FileHelper + + # @return [Interface] a new instance of Interface + # + # source://byebug-11.1.3/lib/byebug/interface.rb:22 + def initialize; end + + # Restores history according to +autosave+ setting. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:118 + def autorestore; end + + # Saves or clears history according to +autosave+ setting. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:111 + def autosave; end + + # source://byebug-11.1.3/lib/byebug/interface.rb:105 + def close; end + + # Returns the value of attribute command_queue. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:19 + def command_queue; end + + # Sets the attribute command_queue + # + # @param value the value to set the attribute command_queue to. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:19 + def command_queue=(_arg0); end + + # Confirms user introduced an affirmative response to the input stream. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:101 + def confirm(prompt); end + + # Prints an error message to the error stream. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:80 + def errmsg(message); end + + # Returns the value of attribute error. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:20 + def error; end + + # Returns the value of attribute history. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:19 + def history; end + + # Sets the attribute history + # + # @param value the value to set the attribute history to. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:19 + def history=(_arg0); end + + # Returns the value of attribute input. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:20 + def input; end + + # source://byebug-11.1.3/lib/byebug/interface.rb:28 + def last_if_empty(input); end + + # Returns the value of attribute output. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:20 + def output; end + + # Reads a new line from the interface's input stream. + # + # read now was empty. + # + # @return [String] New string read or the previous string if the string + # + # source://byebug-11.1.3/lib/byebug/interface.rb:70 + def prepare_input(prompt); end + + # Prints an output message to the output stream without a final "\n". + # + # source://byebug-11.1.3/lib/byebug/interface.rb:94 + def print(message); end + + # Prints an output message to the output stream. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:87 + def puts(message); end + + # Pops a command from the input stream. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:35 + def read_command(prompt); end + + # Pushes lines in +filename+ to the command queue. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:44 + def read_file(filename); end + + # Reads a new line from the interface's input stream, parses it into + # commands and saves it to history. + # + # @return [String] Representing something to be run by the debugger. + # + # source://byebug-11.1.3/lib/byebug/interface.rb:54 + def read_input(prompt, save_hist = T.unsafe(nil)); end + + private + + # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an + # array of commands: [cmd1, cmd2, ..., cmdN] + # + # source://byebug-11.1.3/lib/byebug/interface.rb:128 + def split_commands(cmd_line); end +end + +# Interrupting execution of current thread. +# +# source://byebug-11.1.3/lib/byebug/commands/interrupt.rb:9 +class Byebug::InterruptCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/interrupt.rb:28 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/interrupt.rb:16 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/interrupt.rb:12 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/interrupt.rb:24 + def short_description; end + end +end + +# Enter IRB from byebug's prompt +# +# source://byebug-11.1.3/lib/byebug/commands/irb.rb:11 +class Byebug::IrbCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/irb.rb:30 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/irb.rb:40 + def with_clean_argv; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/irb.rb:18 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/irb.rb:14 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/irb.rb:26 + def short_description; end + end +end + +# Send custom signals to the debugged program. +# +# source://byebug-11.1.3/lib/byebug/commands/kill.rb:9 +class Byebug::KillCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/kill.rb:30 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/kill.rb:16 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/kill.rb:12 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/kill.rb:26 + def short_description; end + end +end + +# Setting to enable/disable linetracing. +# +# source://byebug-11.1.3/lib/byebug/settings/linetrace.rb:9 +class Byebug::LinetraceSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/linetrace.rb:10 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/linetrace.rb:18 + def value; end + + # source://byebug-11.1.3/lib/byebug/settings/linetrace.rb:14 + def value=(val); end +end + +# List parts of the source code. +# +# source://byebug-11.1.3/lib/byebug/commands/list.rb:12 +class Byebug::ListCommand < ::Byebug::Command + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::ParseHelper + + # source://RUBY_ROOT/forwardable.rb:226 + def amend_final(*args, &block); end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:40 + def execute; end + + # source://RUBY_ROOT/forwardable.rb:226 + def max_line(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def size(*args, &block); end + + private + + # Set line range to be printed by list + # + # @return first line number to list + # @return last line number to list + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:79 + def auto_range(direction); end + + # Show a range of lines in the current file. + # + # @param min [Integer] Lower bound + # @param max [Integer] Upper bound + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:115 + def display_lines(min, max); end + + # @param range [String] A string with an integer range format + # @return [String] The lower bound of the given range + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:126 + def lower_bound(range); end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:105 + def move(line, size, direction = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:89 + def parse_range(input); end + + # Line range to be printed by `list`. + # + # If is set, range is parsed from it. + # + # Otherwise it's automatically chosen. + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:60 + def range(input); end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:152 + def source_file_formatter; end + + # @param str [String] A string with an integer range format + # @return [Array] The upper & lower bounds of the given range + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:144 + def split_range(str); end + + # @param range [String] A string with an integer range format + # @return [String] The upper bound of the given range + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:135 + def upper_bound(range); end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/commands/list.rb:69 + def valid_range?(first, last); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/list.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/list.rb:36 + def short_description; end + end +end + +# Setting to customize the number of source code lines to be displayed every +# time the "list" command is invoked. +# +# source://byebug-11.1.3/lib/byebug/settings/listsize.rb:10 +class Byebug::ListsizeSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/listsize.rb:13 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/listsize.rb:17 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/listsize.rb:11 +Byebug::ListsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Interface class for standard byebug use. +# +# source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:7 +class Byebug::LocalInterface < ::Byebug::Interface + # @return [LocalInterface] a new instance of LocalInterface + # + # source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:10 + def initialize; end + + # Reads a single line of input using Readline. If Ctrl-D is pressed, it + # returns "continue", meaning that program's execution will go on. + # + # @param prompt Prompt to be displayed. + # + # source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:23 + def readline(prompt); end + + # Yields the block handling Ctrl-C the following way: if pressed while + # waiting for input, the line is reset to only the prompt and we ask for + # input again. + # + # @note Any external 'INT' traps are overriden during this method. + # + # source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:34 + def with_repl_like_sigint; end + + # Disable any Readline completion procs. + # + # Other gems, for example, IRB could've installed completion procs that are + # dependent on them being loaded. Disable those while byebug is the REPL + # making use of Readline. + # + # source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:51 + def without_readline_completion; end +end + +# source://byebug-11.1.3/lib/byebug/interfaces/local_interface.rb:8 +Byebug::LocalInterface::EOF_ALIAS = T.let(T.unsafe(nil), String) + +# Show methods of specific classes/modules/objects. +# +# source://byebug-11.1.3/lib/byebug/commands/method.rb:10 +class Byebug::MethodCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/commands/method.rb:37 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/method.rb:19 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/method.rb:15 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/method.rb:33 + def short_description; end + end +end + +# Implements the next functionality. +# +# Allows the user the continue execution until the next instruction in the +# current frame. +# +# source://byebug-11.1.3/lib/byebug/commands/next.rb:13 +class Byebug::NextCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/next.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/next.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/next.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/next.rb:28 + def short_description; end + end +end + +# Port number used for remote debugging +# +# source://byebug-11.1.3/lib/byebug/remote.rb:13 +Byebug::PORT = T.let(T.unsafe(nil), Integer) + +# Processes commands in post_mortem mode +# +# source://byebug-11.1.3/lib/byebug/processors/post_mortem_processor.rb:9 +class Byebug::PostMortemProcessor < ::Byebug::CommandProcessor + # source://byebug-11.1.3/lib/byebug/processors/post_mortem_processor.rb:10 + def commands; end + + # source://byebug-11.1.3/lib/byebug/processors/post_mortem_processor.rb:14 + def prompt; end +end + +# Setting to enable/disable post_mortem mode, i.e., a debugger prompt after +# program termination by unhandled exception. +# +# source://byebug-11.1.3/lib/byebug/settings/post_mortem.rb:10 +class Byebug::PostMortemSetting < ::Byebug::Setting + # @return [PostMortemSetting] a new instance of PostMortemSetting + # + # source://byebug-11.1.3/lib/byebug/settings/post_mortem.rb:11 + def initialize; end + + # source://byebug-11.1.3/lib/byebug/settings/post_mortem.rb:15 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/post_mortem.rb:23 + def value; end + + # source://byebug-11.1.3/lib/byebug/settings/post_mortem.rb:19 + def value=(val); end +end + +# source://byebug-11.1.3/lib/byebug/printers/base.rb:6 +module Byebug::Printers; end + +# Base printer +# +# source://byebug-11.1.3/lib/byebug/printers/base.rb:10 +class Byebug::Printers::Base + # source://byebug-11.1.3/lib/byebug/printers/base.rb:16 + def type; end + + private + + # source://byebug-11.1.3/lib/byebug/printers/base.rb:55 + def array_of_args(collection, &_block); end + + # source://byebug-11.1.3/lib/byebug/printers/base.rb:49 + def contents; end + + # source://byebug-11.1.3/lib/byebug/printers/base.rb:63 + def contents_files; end + + # @raise [MissedPath] + # + # source://byebug-11.1.3/lib/byebug/printers/base.rb:22 + def locate(path); end + + # source://byebug-11.1.3/lib/byebug/printers/base.rb:45 + def parts(path); end + + # source://byebug-11.1.3/lib/byebug/printers/base.rb:35 + def translate(string, args = T.unsafe(nil)); end +end + +# source://byebug-11.1.3/lib/byebug/printers/base.rb:12 +class Byebug::Printers::Base::MissedArgument < ::StandardError; end + +# source://byebug-11.1.3/lib/byebug/printers/base.rb:11 +class Byebug::Printers::Base::MissedPath < ::StandardError; end + +# source://byebug-11.1.3/lib/byebug/printers/base.rb:14 +Byebug::Printers::Base::SEPARATOR = T.let(T.unsafe(nil), String) + +# Plain text printer +# +# source://byebug-11.1.3/lib/byebug/printers/plain.rb:10 +class Byebug::Printers::Plain < ::Byebug::Printers::Base + # source://byebug-11.1.3/lib/byebug/printers/plain.rb:11 + def print(path, args = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/printers/plain.rb:17 + def print_collection(path, collection, &block); end + + # source://byebug-11.1.3/lib/byebug/printers/plain.rb:25 + def print_variables(variables, *_unused); end + + private + + # source://byebug-11.1.3/lib/byebug/printers/plain.rb:39 + def contents_files; end +end + +# Enter Pry from byebug's prompt +# +# source://byebug-11.1.3/lib/byebug/commands/pry.rb:10 +class Byebug::PryCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/pry.rb:29 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/pry.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/pry.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/pry.rb:25 + def short_description; end + end +end + +# Exit from byebug. +# +# source://byebug-11.1.3/lib/byebug/commands/quit.rb:9 +class Byebug::QuitCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/quit.rb:33 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/quit.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/quit.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/quit.rb:29 + def short_description; end + end +end + +# source://byebug-11.1.3/lib/byebug/remote/server.rb:6 +module Byebug::Remote; end + +# Client for remote debugging +# +# source://byebug-11.1.3/lib/byebug/remote/client.rb:10 +class Byebug::Remote::Client + # @return [Client] a new instance of Client + # + # source://byebug-11.1.3/lib/byebug/remote/client.rb:13 + def initialize(interface); end + + # Returns the value of attribute interface. + # + # source://byebug-11.1.3/lib/byebug/remote/client.rb:11 + def interface; end + + # Returns the value of attribute socket. + # + # source://byebug-11.1.3/lib/byebug/remote/client.rb:11 + def socket; end + + # Connects to the remote byebug + # + # source://byebug-11.1.3/lib/byebug/remote/client.rb:21 + def start(host = T.unsafe(nil), port = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/remote/client.rb:44 + def started?; end + + private + + # source://byebug-11.1.3/lib/byebug/remote/client.rb:50 + def connect_at(host, port); end +end + +# Server for remote debugging +# +# source://byebug-11.1.3/lib/byebug/remote/server.rb:10 +class Byebug::Remote::Server + # @return [Server] a new instance of Server + # + # source://byebug-11.1.3/lib/byebug/remote/server.rb:13 + def initialize(wait_connection:, &block); end + + # Returns the value of attribute actual_port. + # + # source://byebug-11.1.3/lib/byebug/remote/server.rb:11 + def actual_port; end + + # Start the remote debugging server + # + # source://byebug-11.1.3/lib/byebug/remote/server.rb:22 + def start(host, port); end + + # Returns the value of attribute wait_connection. + # + # source://byebug-11.1.3/lib/byebug/remote/server.rb:11 + def wait_connection; end +end + +# Interface class for remote use of byebug. +# +# source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:9 +class Byebug::RemoteInterface < ::Byebug::Interface + # @return [RemoteInterface] a new instance of RemoteInterface + # + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:10 + def initialize(socket); end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:41 + def close; end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:23 + def confirm(prompt); end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:29 + def print(message); end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:35 + def puts(message); end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:17 + def read_command(prompt); end + + # source://byebug-11.1.3/lib/byebug/interfaces/remote_interface.rb:45 + def readline(prompt); end +end + +# Restart debugged program from within byebug. +# +# source://byebug-11.1.3/lib/byebug/commands/restart.rb:14 +class Byebug::RestartCommand < ::Byebug::Command + include ::Byebug::Helpers::BinHelper + include ::Byebug::Helpers::PathHelper + + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:40 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:54 + def prepend_byebug_bin(cmd); end + + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:59 + def prepend_ruby_bin(cmd); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:25 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:21 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/restart.rb:36 + def short_description; end + end +end + +# Save current settings to use them in another debug session. +# +# source://byebug-11.1.3/lib/byebug/commands/save.rb:9 +class Byebug::SaveCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/save.rb:36 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:50 + def save_breakpoints(file); end + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:56 + def save_catchpoints(file); end + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:62 + def save_displays(file); end + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:66 + def save_settings(file); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/save.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/save.rb:32 + def short_description; end + end +end + +# Setting to customize the file where byebug's history is saved. +# +# source://byebug-11.1.3/lib/byebug/settings/savefile.rb:9 +class Byebug::SavefileSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/savefile.rb:12 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/savefile.rb:16 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/savefile.rb:10 +Byebug::SavefileSetting::DEFAULT = T.let(T.unsafe(nil), String) + +# Interface class for command execution from script files. +# +# source://byebug-11.1.3/lib/byebug/interfaces/script_interface.rb:7 +class Byebug::ScriptInterface < ::Byebug::Interface + # @return [ScriptInterface] a new instance of ScriptInterface + # + # source://byebug-11.1.3/lib/byebug/interfaces/script_interface.rb:8 + def initialize(file, verbose = T.unsafe(nil)); end + + # source://byebug-11.1.3/lib/byebug/interfaces/script_interface.rb:20 + def close; end + + # source://byebug-11.1.3/lib/byebug/interfaces/script_interface.rb:16 + def read_command(prompt); end + + # source://byebug-11.1.3/lib/byebug/interfaces/script_interface.rb:24 + def readline(*_arg0); end +end + +# Processes commands from a file +# +# source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:12 +class Byebug::ScriptProcessor < ::Byebug::CommandProcessor + # source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:28 + def after_repl; end + + # Available commands + # + # source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:13 + def commands; end + + # Prompt shown before reading a command. + # + # source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:37 + def prompt; end + + # source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:17 + def repl; end + + private + + # source://byebug-11.1.3/lib/byebug/processors/script_processor.rb:43 + def without_exceptions; end +end + +# Change byebug settings. +# +# source://byebug-11.1.3/lib/byebug/commands/set.rb:10 +class Byebug::SetCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/set.rb:42 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/set.rb:66 + def get_onoff(arg, default); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/set.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/set.rb:38 + def help; end + + # source://byebug-11.1.3/lib/byebug/commands/set.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/set.rb:34 + def short_description; end + end +end + +# Parent class for all byebug settings. +# +# source://byebug-11.1.3/lib/byebug/setting.rb:9 +class Byebug::Setting + # @return [Setting] a new instance of Setting + # + # source://byebug-11.1.3/lib/byebug/setting.rb:14 + def initialize; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/setting.rb:18 + def boolean?; end + + # source://byebug-11.1.3/lib/byebug/setting.rb:28 + def help; end + + # @return [Boolean] + # + # source://byebug-11.1.3/lib/byebug/setting.rb:22 + def integer?; end + + # source://byebug-11.1.3/lib/byebug/setting.rb:37 + def to_s; end + + # source://byebug-11.1.3/lib/byebug/setting.rb:32 + def to_sym; end + + # Returns the value of attribute value. + # + # source://byebug-11.1.3/lib/byebug/setting.rb:10 + def value; end + + # Sets the attribute value + # + # @param value the value to set the attribute value to. + # + # source://byebug-11.1.3/lib/byebug/setting.rb:10 + def value=(_arg0); end + + class << self + # source://byebug-11.1.3/lib/byebug/setting.rb:46 + def [](name); end + + # source://byebug-11.1.3/lib/byebug/setting.rb:50 + def []=(name, value); end + + # source://byebug-11.1.3/lib/byebug/setting.rb:54 + def find(shortcut); end + + # @todo DRY this up. Very similar code exists in the CommandList class + # + # source://byebug-11.1.3/lib/byebug/setting.rb:65 + def help_all; end + + # source://byebug-11.1.3/lib/byebug/setting.rb:42 + def settings; end + end +end + +# Show byebug settings. +# +# source://byebug-11.1.3/lib/byebug/commands/show.rb:9 +class Byebug::ShowCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/show.rb:35 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/show.rb:17 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/show.rb:31 + def help; end + + # source://byebug-11.1.3/lib/byebug/commands/show.rb:13 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/show.rb:27 + def short_description; end + end +end + +# Allows the user to continue execution until the next breakpoint, as +# long as it is different from the current one +# +# source://byebug-11.1.3/lib/byebug/commands/skip.rb:11 +class Byebug::SkipCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:70 + def auto_run; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:77 + def execute; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:53 + def initialize_attributes; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:60 + def keep_execution; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:64 + def reset_attributes; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:41 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:18 + def file_line; end + + # Sets the attribute file_line + # + # @param value the value to set the attribute file_line to. + # + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:15 + def file_line=(_arg0); end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:22 + def file_path; end + + # Sets the attribute file_path + # + # @param value the value to set the attribute file_path to. + # + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:15 + def file_path=(_arg0); end + + # Returns the value of attribute previous_autolist. + # + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:16 + def previous_autolist; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:37 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:31 + def restore_autolist; end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:26 + def setup_autolist(value); end + + # source://byebug-11.1.3/lib/byebug/commands/skip.rb:49 + def short_description; end + end +end + +# Execute a file containing byebug commands. +# +# It can be used to restore a previously saved debugging session. +# +# source://byebug-11.1.3/lib/byebug/commands/source.rb:11 +class Byebug::SourceCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/source.rb:31 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/source.rb:19 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/source.rb:15 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/source.rb:27 + def short_description; end + end +end + +# Formats specific line ranges in a source file +# +# source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:10 +class Byebug::SourceFileFormatter + include ::Byebug::Helpers::FileHelper + + # @return [SourceFileFormatter] a new instance of SourceFileFormatter + # + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:15 + def initialize(file, annotator); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:67 + def amend(line, ceiling); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:51 + def amend_final(line); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:47 + def amend_initial(line); end + + # Returns the value of attribute annotator. + # + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:13 + def annotator; end + + # Returns the value of attribute file. + # + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:13 + def file; end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:20 + def lines(min, max); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:33 + def lines_around(center); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:55 + def max_initial_line; end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:59 + def max_line; end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:37 + def range_around(center); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:41 + def range_from(min); end + + # source://byebug-11.1.3/lib/byebug/source_file_formatter.rb:63 + def size; end +end + +# Setting to enable/disable the display of backtraces when evaluations raise +# errors. +# +# source://byebug-11.1.3/lib/byebug/settings/stack_on_error.rb:10 +class Byebug::StackOnErrorSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/stack_on_error.rb:11 + def banner; end +end + +# Implements the step functionality. +# +# Allows the user the continue execution until the next instruction, possibily +# in a different frame. Use step to step into method calls or blocks. +# +# source://byebug-11.1.3/lib/byebug/commands/step.rb:13 +class Byebug::StepCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/step.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/step.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/step.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/step.rb:28 + def short_description; end + end +end + +# Subcommand additions. +# +# source://byebug-11.1.3/lib/byebug/subcommands.rb:12 +module Byebug::Subcommands + extend ::Forwardable + + mixes_in_class_methods ::Byebug::Subcommands::ClassMethods + + # Delegates to subcommands or prints help if no subcommand specified. + # + # @raise [CommandNotFound] + # + # source://byebug-11.1.3/lib/byebug/subcommands.rb:23 + def execute; end + + # source://RUBY_ROOT/forwardable.rb:226 + def subcommand_list(*args, &block); end + + class << self + # @private + # + # source://byebug-11.1.3/lib/byebug/subcommands.rb:13 + def included(command); end + end +end + +# Class methods added to subcommands +# +# source://byebug-11.1.3/lib/byebug/subcommands.rb:36 +module Byebug::Subcommands::ClassMethods + include ::Byebug::Helpers::ReflectionHelper + + # Default help text for a command with subcommands + # + # source://byebug-11.1.3/lib/byebug/subcommands.rb:42 + def help; end + + # Command's subcommands. + # + # source://byebug-11.1.3/lib/byebug/subcommands.rb:49 + def subcommand_list; end +end + +# Reopens the +thread+ command to define the +resume+ subcommand +# +# source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:12 +class Byebug::ThreadCommand < ::Byebug::Command + include ::Byebug::Subcommands + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Subcommands::ClassMethods + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread.rb:30 + def short_description; end + end +end + +# Information about the current thread +# +# source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:13 +class Byebug::ThreadCommand::CurrentCommand < ::Byebug::Command + include ::Byebug::Helpers::ThreadHelper + + # source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/current.rb:28 + def short_description; end + end +end + +# Information about threads +# +# source://byebug-11.1.3/lib/byebug/commands/thread/list.rb:13 +class Byebug::ThreadCommand::ListCommand < ::Byebug::Command + include ::Byebug::Helpers::ThreadHelper + + # source://byebug-11.1.3/lib/byebug/commands/thread/list.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread/list.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/list.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/list.rb:28 + def short_description; end + end +end + +# Resumes the specified thread +# +# source://byebug-11.1.3/lib/byebug/commands/thread/resume.rb:13 +class Byebug::ThreadCommand::ResumeCommand < ::Byebug::Command + include ::Byebug::Helpers::ThreadHelper + + # source://byebug-11.1.3/lib/byebug/commands/thread/resume.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread/resume.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/resume.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/resume.rb:28 + def short_description; end + end +end + +# Stops the specified thread +# +# source://byebug-11.1.3/lib/byebug/commands/thread/stop.rb:13 +class Byebug::ThreadCommand::StopCommand < ::Byebug::Command + include ::Byebug::Helpers::ThreadHelper + + # source://byebug-11.1.3/lib/byebug/commands/thread/stop.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread/stop.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/stop.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/stop.rb:28 + def short_description; end + end +end + +# Switches to the specified thread +# +# source://byebug-11.1.3/lib/byebug/commands/thread/switch.rb:13 +class Byebug::ThreadCommand::SwitchCommand < ::Byebug::Command + include ::Byebug::Helpers::ThreadHelper + + # source://byebug-11.1.3/lib/byebug/commands/thread/switch.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/thread/switch.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/switch.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/thread/switch.rb:28 + def short_description; end + end +end + +class Byebug::ThreadsTable; end + +# Show (and possibily stop) at every line that changes a global variable. +# +# source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:9 +class Byebug::TracevarCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:32 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:48 + def on_change(name, value, stop); end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:16 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:10 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/tracevar.rb:28 + def short_description; end + end +end + +# Remove expressions from display list. +# +# source://byebug-11.1.3/lib/byebug/commands/undisplay.rb:10 +class Byebug::UndisplayCommand < ::Byebug::Command + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/undisplay.rb:35 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/undisplay.rb:19 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/undisplay.rb:15 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/undisplay.rb:31 + def short_description; end + end +end + +# Stop tracing a global variable. +# +# source://byebug-11.1.3/lib/byebug/commands/untracevar.rb:9 +class Byebug::UntracevarCommand < ::Byebug::Command + # source://byebug-11.1.3/lib/byebug/commands/untracevar.rb:26 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/untracevar.rb:14 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/untracevar.rb:10 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/untracevar.rb:22 + def short_description; end + end +end + +# Move the current frame up in the backtrace. +# +# source://byebug-11.1.3/lib/byebug/commands/up.rb:12 +class Byebug::UpCommand < ::Byebug::Command + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + + # source://byebug-11.1.3/lib/byebug/commands/up.rb:36 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/up.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/up.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/up.rb:32 + def short_description; end + end +end + +# Shows variables and its values +# +# source://byebug-11.1.3/lib/byebug/commands/var/all.rb:12 +class Byebug::VarCommand < ::Byebug::Command + include ::Byebug::Subcommands + extend ::Byebug::Helpers::ReflectionHelper + extend ::Byebug::Subcommands::ClassMethods + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var.rb:25 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var.rb:21 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var.rb:33 + def short_description; end + end +end + +# Shows global, instance and local variables +# +# source://byebug-11.1.3/lib/byebug/commands/var/all.rb:13 +class Byebug::VarCommand::AllCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::VarHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/all.rb:34 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/all.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/all.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/all.rb:30 + def short_description; end + end +end + +# Information about arguments of the current method/block +# +# source://byebug-11.1.3/lib/byebug/commands/var/args.rb:13 +class Byebug::VarCommand::ArgsCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::VarHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/args.rb:34 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/args.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/args.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/args.rb:30 + def short_description; end + end +end + +# Shows constants +# +# source://byebug-11.1.3/lib/byebug/commands/var/const.rb:13 +class Byebug::VarCommand::ConstCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/const.rb:34 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/var/const.rb:44 + def str_obj; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/const.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/const.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/const.rb:30 + def short_description; end + end +end + +# Shows global variables +# +# source://byebug-11.1.3/lib/byebug/commands/var/global.rb:11 +class Byebug::VarCommand::GlobalCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::VarHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/global.rb:32 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/global.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/global.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/global.rb:28 + def short_description; end + end +end + +# Shows instance variables +# +# source://byebug-11.1.3/lib/byebug/commands/var/instance.rb:13 +class Byebug::VarCommand::InstanceCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::VarHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/instance.rb:34 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/instance.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/instance.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/instance.rb:30 + def short_description; end + end +end + +# Shows local variables in current scope +# +# source://byebug-11.1.3/lib/byebug/commands/var/local.rb:13 +class Byebug::VarCommand::LocalCommand < ::Byebug::Command + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::VarHelper + + # source://byebug-11.1.3/lib/byebug/commands/var/local.rb:34 + def execute; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/var/local.rb:22 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/var/local.rb:18 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/var/local.rb:30 + def short_description; end + end +end + +# Show current backtrace. +# +# source://byebug-11.1.3/lib/byebug/commands/where.rb:11 +class Byebug::WhereCommand < ::Byebug::Command + include ::Byebug::Helpers::FrameHelper + + # source://byebug-11.1.3/lib/byebug/commands/where.rb:39 + def execute; end + + private + + # source://byebug-11.1.3/lib/byebug/commands/where.rb:45 + def print_backtrace; end + + class << self + # source://byebug-11.1.3/lib/byebug/commands/where.rb:20 + def description; end + + # source://byebug-11.1.3/lib/byebug/commands/where.rb:16 + def regexp; end + + # source://byebug-11.1.3/lib/byebug/commands/where.rb:35 + def short_description; end + end +end + +# Setting to customize the maximum width of byebug's output. +# +# source://byebug-11.1.3/lib/byebug/settings/width.rb:9 +class Byebug::WidthSetting < ::Byebug::Setting + # source://byebug-11.1.3/lib/byebug/settings/width.rb:12 + def banner; end + + # source://byebug-11.1.3/lib/byebug/settings/width.rb:16 + def to_s; end +end + +# source://byebug-11.1.3/lib/byebug/settings/width.rb:10 +Byebug::WidthSetting::DEFAULT = T.let(T.unsafe(nil), Integer) + +# Extends the extension class to be able to pass information about the +# debugging environment from the c-extension to the user. +# +# source://byebug-11.1.3/lib/byebug/core.rb:113 +class Exception + # Returns the value of attribute __bb_context. + # + # source://byebug-11.1.3/lib/byebug/core.rb:114 + def __bb_context; end +end + +# Adds a `byebug` method to the Kernel module. +# +# Dropping a `byebug` call anywhere in your code, you get a debug prompt. +# +# source://byebug-11.1.3/lib/byebug/attacher.rb:34 +module Kernel + # source://byebug-11.1.3/lib/byebug/attacher.rb:35 + def byebug; end + + # source://byebug-11.1.3/lib/byebug/attacher.rb:35 + def debugger; end + + # source://byebug-11.1.3/lib/byebug/attacher.rb:41 + def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end +end diff --git a/sorbet/rbi/gems/codecov.rbi b/sorbet/rbi/gems/codecov.rbi deleted file mode 100644 index 870ec234..00000000 --- a/sorbet/rbi/gems/codecov.rbi +++ /dev/null @@ -1,49 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/codecov/all/codecov.rbi -# -# codecov-0.6.0 - -module Codecov - extend Codecov::Configuration -end -module Codecov::SimpleCov -end -class Codecov::SimpleCov::Formatter - def file_network; end - def file_to_codecov(file); end - def format(report); end - def result_to_codecov(result); end - def result_to_codecov_coverage(result); end - def result_to_codecov_messages(result); end - def result_to_codecov_report(result); end - def shortened_filename(file); end -end -module Codecov::Configuration - def pass_ci_if_error; end - def pass_ci_if_error=(arg0); end -end -class Codecov::Uploader - def self.black(str); end - def self.build_params(ci); end - def self.detect_ci; end - def self.display_header; end - def self.green(str); end - def self.gzip_report(report); end - def self.handle_report_response(report); end - def self.net_blockers(switch); end - def self.red(str); end - def self.retry_request(req, https); end - def self.upload(report, disable_net_blockers = nil); end - def self.upload_to_codecov(ci, report); end - def self.upload_to_v2(url, report, query, query_without_token); end - def self.upload_to_v4(url, report, query, query_without_token); end -end -class SimpleCov::Formatter::Codecov - def format(result, disable_net_blockers = nil); end -end diff --git a/sorbet/rbi/gems/codecov@0.6.0.rbi b/sorbet/rbi/gems/codecov@0.6.0.rbi new file mode 100644 index 00000000..98215d6a --- /dev/null +++ b/sorbet/rbi/gems/codecov@0.6.0.rbi @@ -0,0 +1,208 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `codecov` gem. +# Please instead update this file by running `bin/tapioca gem codecov`. + +# source://codecov-0.6.0/lib/codecov/version.rb:3 +module Codecov + extend ::Codecov::Configuration +end + +# source://codecov-0.6.0/lib/codecov/configuration.rb:4 +module Codecov::Configuration + # Returns the value of attribute pass_ci_if_error. + # + # source://codecov-0.6.0/lib/codecov/configuration.rb:5 + def pass_ci_if_error; end + + # Sets the attribute pass_ci_if_error + # + # @param value the value to set the attribute pass_ci_if_error to. + # + # source://codecov-0.6.0/lib/codecov/configuration.rb:5 + def pass_ci_if_error=(_arg0); end +end + +# source://codecov-0.6.0/lib/codecov/formatter.rb:8 +module Codecov::SimpleCov; end + +# source://codecov-0.6.0/lib/codecov/formatter.rb:9 +class Codecov::SimpleCov::Formatter + # source://codecov-0.6.0/lib/codecov/formatter.rb:12 + def format(report); end + + private + + # source://codecov-0.6.0/lib/codecov/formatter.rb:52 + def file_network; end + + # Format coverage data for a single file for the Codecov.io API. + # + # @param file [SimpleCov::SourceFile] The file to process. + # @return [Array] + # + # source://codecov-0.6.0/lib/codecov/formatter.rb:104 + def file_to_codecov(file); end + + # Format SimpleCov coverage data for the Codecov.io API. + # + # @param result [SimpleCov::Result] The coverage data to process. + # @return [Hash] + # + # source://codecov-0.6.0/lib/codecov/formatter.rb:39 + def result_to_codecov(result); end + + # Format SimpleCov coverage data for the Codecov.io coverage API. + # + # @param result [SimpleCov::Result] The coverage data to process. + # @return [Hash] + # + # source://codecov-0.6.0/lib/codecov/formatter.rb:82 + def result_to_codecov_coverage(result); end + + # Format SimpleCov coverage data for the Codecov.io messages API. + # + # @param result [SimpleCov::Result] The coverage data to process. + # @return [Hash] + # + # source://codecov-0.6.0/lib/codecov/formatter.rb:92 + def result_to_codecov_messages(result); end + + # source://codecov-0.6.0/lib/codecov/formatter.rb:47 + def result_to_codecov_report(result); end + + # source://codecov-0.6.0/lib/codecov/formatter.rb:120 + def shortened_filename(file); end +end + +# source://codecov-0.6.0/lib/codecov/formatter.rb:10 +Codecov::SimpleCov::Formatter::RESULT_FILE_NAME = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:11 +class Codecov::Uploader + class << self + # Convenience color methods + # + # source://codecov-0.6.0/lib/codecov/uploader.rb:557 + def black(str); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:130 + def build_params(ci); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:78 + def detect_ci; end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:64 + def display_header; end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:565 + def green(str); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:393 + def gzip_report(report); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:516 + def handle_report_response(report); end + + # Toggle VCR and WebMock on or off + # + # @param switch Toggle switch for Net Blockers. + # @return [Boolean] + # + # source://codecov-0.6.0/lib/codecov/uploader.rb:530 + def net_blockers(switch); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:561 + def red(str); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:366 + def retry_request(req, https); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:36 + def upload(report, disable_net_blockers = T.unsafe(nil)); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:404 + def upload_to_codecov(ci, report); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:494 + def upload_to_v2(url, report, query, query_without_token); end + + # source://codecov-0.6.0/lib/codecov/uploader.rb:433 + def upload_to_v4(url, report, query, query_without_token); end + end +end + +# source://codecov-0.6.0/lib/codecov/uploader.rb:14 +Codecov::Uploader::APPVEYOR = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:15 +Codecov::Uploader::AZUREPIPELINES = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:16 +Codecov::Uploader::BITBUCKET = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:17 +Codecov::Uploader::BITRISE = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:18 +Codecov::Uploader::BUILDKITE = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:19 +Codecov::Uploader::CIRCLE = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:20 +Codecov::Uploader::CIRRUS = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:21 +Codecov::Uploader::CODEBUILD = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:22 +Codecov::Uploader::CODESHIP = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:23 +Codecov::Uploader::DRONEIO = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:24 +Codecov::Uploader::GITHUB = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:25 +Codecov::Uploader::GITLAB = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:26 +Codecov::Uploader::HEROKU = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:27 +Codecov::Uploader::JENKINS = T.let(T.unsafe(nil), String) + +# CIs +# +# source://codecov-0.6.0/lib/codecov/uploader.rb:13 +Codecov::Uploader::RECOGNIZED_CIS = T.let(T.unsafe(nil), Array) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:28 +Codecov::Uploader::SEMAPHORE = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:29 +Codecov::Uploader::SHIPPABLE = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:30 +Codecov::Uploader::SOLANO = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:31 +Codecov::Uploader::TEAMCITY = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:32 +Codecov::Uploader::TRAVIS = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/uploader.rb:33 +Codecov::Uploader::WERCKER = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov/version.rb:4 +Codecov::VERSION = T.let(T.unsafe(nil), String) + +# source://codecov-0.6.0/lib/codecov.rb:12 +class SimpleCov::Formatter::Codecov + # source://codecov-0.6.0/lib/codecov.rb:13 + def format(result, disable_net_blockers = T.unsafe(nil)); end +end diff --git a/sorbet/rbi/gems/coderay.rbi b/sorbet/rbi/gems/coderay.rbi deleted file mode 100644 index 49b4687e..00000000 --- a/sorbet/rbi/gems/coderay.rbi +++ /dev/null @@ -1,92 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/coderay/all/coderay.rbi -# -# coderay-1.1.3 - -module CodeRay - def self.coderay_path(*path); end - def self.encode(code, lang, format, options = nil); end - def self.encode_file(filename, format, options = nil); end - def self.encode_tokens(tokens, format, options = nil); end - def self.encoder(format, options = nil); end - def self.get_scanner_options(options); end - def self.highlight(code, lang, options = nil, format = nil); end - def self.highlight_file(filename, options = nil, format = nil); end - def self.scan(code, lang, options = nil, &block); end - def self.scan_file(filename, lang = nil, options = nil, &block); end - def self.scanner(lang, options = nil, &block); end -end -module CodeRay::PluginHost - def [](id, *args, &blk); end - def all_plugins; end - def const_missing(const); end - def default(id = nil); end - def list; end - def load(id, *args, &blk); end - def load_all; end - def load_plugin_map; end - def make_plugin_hash; end - def map(hash); end - def path_to(plugin_id); end - def plugin_hash; end - def plugin_path(*args); end - def register(plugin, id); end - def self.extended(mod); end - def validate_id(id); end -end -class CodeRay::PluginHost::PluginNotFound < LoadError -end -class CodeRay::PluginHost::HostNotFound < LoadError -end -module CodeRay::Encoders - extend CodeRay::PluginHost -end -module CodeRay::Plugin - def aliases; end - def plugin_host(host = nil); end - def plugin_id; end - def register_for(id); end - def title(title = nil); end -end -class CodeRay::Encoders::Encoder - def <<(token); end - def begin_group(kind); end - def begin_line(kind); end - def compile(tokens, options = nil); end - def encode(code, lang, options = nil); end - def encode_tokens(tokens, options = nil); end - def end_group(kind); end - def end_line(kind); end - def file_extension; end - def finish(options); end - def get_output(options); end - def highlight(code, lang, options = nil); end - def initialize(options = nil); end - def options; end - def options=(arg0); end - def output(data); end - def scanner; end - def scanner=(arg0); end - def self.const_missing(sym); end - def self.file_extension; end - def setup(options); end - def text_token(text, kind); end - def token(content, kind); end - def tokens(tokens, options = nil); end - extend CodeRay::Plugin -end -class CodeRay::Encoders::Terminal < CodeRay::Encoders::Encoder - def begin_group(kind); end - def begin_line(kind); end - def end_group(kind); end - def end_line(kind); end - def open_token(kind); end - def setup(options); end - def text_token(text, kind); end -end diff --git a/sorbet/rbi/gems/coderay@1.1.3.rbi b/sorbet/rbi/gems/coderay@1.1.3.rbi new file mode 100644 index 00000000..4a28a81b --- /dev/null +++ b/sorbet/rbi/gems/coderay@1.1.3.rbi @@ -0,0 +1,3437 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `coderay` gem. +# Please instead update this file by running `bin/tapioca gem coderay`. + +# = CodeRay Library +# +# CodeRay is a Ruby library for syntax highlighting. +# +# I try to make CodeRay easy to use and intuitive, but at the same time fully +# featured, complete, fast and efficient. +# +# See README. +# +# It consists mainly of +# * the main engine: CodeRay (Scanners::Scanner, Tokens, Encoders::Encoder) +# * the plugin system: PluginHost, Plugin +# * the scanners in CodeRay::Scanners +# * the encoders in CodeRay::Encoders +# * the styles in CodeRay::Styles +# +# Here's a fancy graphic to light up this gray docu: +# +# http://cycnus.de/raindark/coderay/scheme.png +# +# == Documentation +# +# See CodeRay, Encoders, Scanners, Tokens. +# +# == Usage +# +# Remember you need RubyGems to use CodeRay, unless you have it in your load +# path. Run Ruby with -rubygems option if required. +# +# === Highlight Ruby code in a string as html +# +# require 'coderay' +# print CodeRay.scan('puts "Hello, world!"', :ruby).html +# +# # prints something like this: +# puts "Hello, world!" +# +# +# === Highlight C code from a file in a html div +# +# require 'coderay' +# print CodeRay.scan(File.read('ruby.h'), :c).div +# print CodeRay.scan_file('ruby.h').html.div +# +# You can include this div in your page. The used CSS styles can be printed with +# +# % coderay_stylesheet +# +# === Highlight without typing too much +# +# If you are one of the hasty (or lazy, or extremely curious) people, just run this file: +# +# % ruby -rubygems /path/to/coderay/coderay.rb > example.html +# +# and look at the file it created in your browser. +# +# = CodeRay Module +# +# The CodeRay module provides convenience methods for the engine. +# +# * The +lang+ and +format+ arguments select Scanner and Encoder to use. These are +# simply lower-case symbols, like :python or :html. +# * All methods take an optional hash as last parameter, +options+, that is send to +# the Encoder / Scanner. +# * Input and language are always sorted in this order: +code+, +lang+. +# (This is in alphabetical order, if you need a mnemonic ;) +# +# You should be able to highlight everything you want just using these methods; +# so there is no need to dive into CodeRay's deep class hierarchy. +# +# The examples in the demo directory demonstrate common cases using this interface. +# +# = Basic Access Ways +# +# Read this to get a general view what CodeRay provides. +# +# == Scanning +# +# Scanning means analysing an input string, splitting it up into Tokens. +# Each Token knows about what type it is: string, comment, class name, etc. +# +# Each +lang+ (language) has its own Scanner; for example, :ruby code is +# handled by CodeRay::Scanners::Ruby. +# +# CodeRay.scan:: Scan a string in a given language into Tokens. +# This is the most common method to use. +# CodeRay.scan_file:: Scan a file and guess the language using FileType. +# +# The Tokens object you get from these methods can encode itself; see Tokens. +# +# == Encoding +# +# Encoding means compiling Tokens into an output. This can be colored HTML or +# LaTeX, a textual statistic or just the number of non-whitespace tokens. +# +# Each Encoder provides output in a specific +format+, so you select Encoders via +# formats like :html or :statistic. +# +# CodeRay.encode:: Scan and encode a string in a given language. +# CodeRay.encode_tokens:: Encode the given tokens. +# CodeRay.encode_file:: Scan a file, guess the language using FileType and encode it. +# +# == All-in-One Encoding +# +# CodeRay.encode:: Highlight a string with a given input and output format. +# +# == Instanciating +# +# You can use an Encoder instance to highlight multiple inputs. This way, the setup +# for this Encoder must only be done once. +# +# CodeRay.encoder:: Create an Encoder instance with format and options. +# CodeRay.scanner:: Create an Scanner instance for lang, with '' as default code. +# +# To make use of CodeRay.scanner, use CodeRay::Scanner::code=. +# +# The scanning methods provide more flexibility; we recommend to use these. +# +# == Reusing Scanners and Encoders +# +# If you want to re-use scanners and encoders (because that is faster), see +# CodeRay::Duo for the most convenient (and recommended) interface. +# +# source://coderay-1.1.3/lib/coderay.rb:126 +module CodeRay + class << self + # Assuming the path is a subpath of lib/coderay/ + # + # source://coderay-1.1.3/lib/coderay.rb:133 + def coderay_path(*path); end + + # Encode a string. + # + # This scans +code+ with the the Scanner for +lang+ and then + # encodes it with the Encoder for +format+. + # +options+ will be passed to the Encoder. + # + # See CodeRay::Encoder.encode. + # + # source://coderay-1.1.3/lib/coderay.rb:196 + def encode(code, lang, format, options = T.unsafe(nil)); end + + # Encodes +filename+ (a path to a code file) with the Scanner for +lang+. + # + # See CodeRay.scan_file. + # Notice that the second argument is the output +format+, not the input language. + # + # Example: + # require 'coderay' + # page = CodeRay.encode_file 'some_c_code.c', :html + # + # source://coderay-1.1.3/lib/coderay.rb:221 + def encode_file(filename, format, options = T.unsafe(nil)); end + + # Encode pre-scanned Tokens. + # Use this together with CodeRay.scan: + # + # require 'coderay' + # + # # Highlight a short Ruby code example in a HTML span + # tokens = CodeRay.scan '1 + 2', :ruby + # puts CodeRay.encode_tokens(tokens, :span) + # + # source://coderay-1.1.3/lib/coderay.rb:209 + def encode_tokens(tokens, format, options = T.unsafe(nil)); end + + # Finds the Encoder class for +format+ and creates an instance, passing + # +options+ to it. + # + # Example: + # require 'coderay' + # + # stats = CodeRay.encoder(:statistic) + # stats.encode("puts 17 + 4\n", :ruby) + # + # puts '%d out of %d tokens have the kind :integer.' % [ + # stats.type_stats[:integer].count, + # stats.real_token_count + # ] + # #-> 2 out of 4 tokens have the kind :integer. + # + # source://coderay-1.1.3/lib/coderay.rb:260 + def encoder(format, options = T.unsafe(nil)); end + + # Extract the options for the scanner from the +options+ hash. + # + # Returns an empty Hash if :scanner_options is not set. + # + # This is used if a method like CodeRay.encode has to provide options + # for Encoder _and_ scanner. + # + # source://coderay-1.1.3/lib/coderay.rb:278 + def get_scanner_options(options); end + + # Highlight a string into a HTML
. + # + # CSS styles use classes, so you have to include a stylesheet + # in your output. + # + # See encode. + # + # source://coderay-1.1.3/lib/coderay.rb:232 + def highlight(code, lang, options = T.unsafe(nil), format = T.unsafe(nil)); end + + # Highlight a file into a HTML
. + # + # CSS styles use classes, so you have to include a stylesheet + # in your output. + # + # See encode. + # + # source://coderay-1.1.3/lib/coderay.rb:242 + def highlight_file(filename, options = T.unsafe(nil), format = T.unsafe(nil)); end + + # Scans the given +code+ (a String) with the Scanner for +lang+. + # + # This is a simple way to use CodeRay. Example: + # require 'coderay' + # page = CodeRay.scan("puts 'Hello, world!'", :ruby).html + # + # See also demo/demo_simple. + # + # source://coderay-1.1.3/lib/coderay.rb:168 + def scan(code, lang, options = T.unsafe(nil), &block); end + + # Scans +filename+ (a path to a code file) with the Scanner for +lang+. + # + # If +lang+ is :auto or omitted, the CodeRay::FileType module is used to + # determine it. If it cannot find out what type it is, it uses + # CodeRay::Scanners::Text. + # + # Calls CodeRay.scan. + # + # Example: + # require 'coderay' + # page = CodeRay.scan_file('some_c_code.c').html + # + # source://coderay-1.1.3/lib/coderay.rb:183 + def scan_file(filename, lang = T.unsafe(nil), options = T.unsafe(nil), &block); end + + # Finds the Scanner class for +lang+ and creates an instance, passing + # +options+ to it. + # + # See Scanner.new. + # + # source://coderay-1.1.3/lib/coderay.rb:268 + def scanner(lang, options = T.unsafe(nil), &block); end + end +end + +# source://coderay-1.1.3/lib/coderay.rb:130 +CodeRay::CODERAY_PATH = T.let(T.unsafe(nil), String) + +# = Duo +# +# A Duo is a convenient way to use CodeRay. You just create a Duo, +# giving it a lang (language of the input code) and a format (desired +# output format), and call Duo#highlight with the code. +# +# Duo makes it easy to re-use both scanner and encoder for a repetitive +# task. It also provides a very easy interface syntax: +# +# require 'coderay' +# CodeRay::Duo[:python, :div].highlight 'import this' +# +# Until you want to do uncommon things with CodeRay, I recommend to use +# this method, since it takes care of everything. +# +# source://coderay-1.1.3/lib/coderay/duo.rb:17 +class CodeRay::Duo + # Create a new Duo, holding a lang and a format to highlight code. + # + # simple: + # CodeRay::Duo[:ruby, :html].highlight 'bla 42' + # + # with options: + # CodeRay::Duo[:ruby, :html, :hint => :debug].highlight '????::??' + # + # alternative syntax without options: + # CodeRay::Duo[:ruby => :statistic].encode 'class << self; end' + # + # alternative syntax with options: + # CodeRay::Duo[{ :ruby => :statistic }, :do => :something].encode 'abc' + # + # The options are forwarded to scanner and encoder + # (see CodeRay.get_scanner_options). + # + # @return [Duo] a new instance of Duo + # + # source://coderay-1.1.3/lib/coderay/duo.rb:37 + def initialize(lang = T.unsafe(nil), format = T.unsafe(nil), options = T.unsafe(nil)); end + + # Tokenize and highlight the code using +scanner+ and +encoder+. + # Allows to use Duo like a proc object: + # + # CodeRay::Duo[:python => :yaml].call(code) + # + # or, in Ruby 1.9 and later: + # + # CodeRay::Duo[:python => :yaml].(code) + # + # source://coderay-1.1.3/lib/coderay/duo.rb:64 + def call(code, options = T.unsafe(nil)); end + + # Tokenize and highlight the code using +scanner+ and +encoder+. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:64 + def encode(code, options = T.unsafe(nil)); end + + # The encoder of the duo. Only created once. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:59 + def encoder; end + + # Returns the value of attribute format. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def format; end + + # Sets the attribute format + # + # @param value the value to set the attribute format to. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def format=(_arg0); end + + # Tokenize and highlight the code using +scanner+ and +encoder+. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:64 + def highlight(code, options = T.unsafe(nil)); end + + # Returns the value of attribute lang. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def lang; end + + # Sets the attribute lang + # + # @param value the value to set the attribute lang to. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def lang=(_arg0); end + + # Returns the value of attribute options. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def options; end + + # Sets the attribute options + # + # @param value the value to set the attribute options to. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:19 + def options=(_arg0); end + + # The scanner of the duo. Only created once. + # + # source://coderay-1.1.3/lib/coderay/duo.rb:54 + def scanner; end + + class << self + # To allow calls like Duo[:ruby, :html].highlight. + def [](*_arg0); end + end +end + +# This module holds the Encoder class and its subclasses. +# For example, the HTML encoder is named CodeRay::Encoders::HTML +# can be found in coderay/encoders/html. +# +# Encoders also provides methods and constants for the register +# mechanism and the [] method that returns the Encoder class +# belonging to the given format. +# +# source://coderay-1.1.3/lib/coderay/encoders.rb:10 +module CodeRay::Encoders + extend ::CodeRay::PluginHost +end + +# A simple Filter that removes all tokens of the :comment kind. +# +# Alias: +remove_comments+ +# +# Usage: +# CodeRay.scan('print # foo', :ruby).comment_filter.text +# #-> "print " +# +# See also: TokenKindFilter, LinesOfCode +# +# source://coderay-1.1.3/lib/coderay/encoders/comment_filter.rb:15 +class CodeRay::Encoders::CommentFilter < ::CodeRay::Encoders::TokenKindFilter; end + +# source://coderay-1.1.3/lib/coderay/encoders/comment_filter.rb:19 +CodeRay::Encoders::CommentFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# Returns the number of tokens. +# +# Text and block tokens are counted. +# +# source://coderay-1.1.3/lib/coderay/encoders/count.rb:7 +class CodeRay::Encoders::Count < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:29 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:29 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:29 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:29 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:25 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:19 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/count.rb:13 + def setup(options); end +end + +# = Debug Encoder +# +# Fast encoder producing simple debug output. +# +# It is readable and diff-able and is used for testing. +# +# You cannot fully restore the tokens information from the +# output, because consecutive :space tokens are merged. +# +# See also: Scanners::Debug +# +# source://coderay-1.1.3/lib/coderay/encoders/debug.rb:14 +class CodeRay::Encoders::Debug < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/debug.rb:30 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug.rb:38 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug.rb:34 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug.rb:42 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug.rb:20 + def text_token(text, kind); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/debug.rb:18 +CodeRay::Encoders::Debug::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# = Debug Lint Encoder +# +# Debug encoder with additional checks for: +# +# - empty tokens +# - incorrect nesting +# +# It will raise an InvalidTokenStream exception when any of the above occurs. +# +# See also: Encoders::Debug +# +# source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:16 +class CodeRay::Encoders::DebugLint < ::CodeRay::Encoders::Debug + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:26 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:37 + def begin_line(kind); end + + # @raise [Lint::IncorrectTokenGroupNesting] + # + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:31 + def end_group(kind); end + + # @raise [Lint::IncorrectTokenGroupNesting] + # + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:42 + def end_line(kind); end + + # @raise [Lint::EmptyToken] + # + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:20 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:55 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/debug_lint.rb:50 + def setup(options); end +end + +# Wraps HTML output into a DIV element, using inline styles by default. +# +# See Encoders::HTML for available options. +# +# source://coderay-1.1.3/lib/coderay/encoders/div.rb:9 +class CodeRay::Encoders::Div < ::CodeRay::Encoders::HTML; end + +# source://coderay-1.1.3/lib/coderay/encoders/div.rb:15 +CodeRay::Encoders::Div::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/div.rb:11 +CodeRay::Encoders::Div::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# = Encoder +# +# The Encoder base class. Together with Scanner and +# Tokens, it forms the highlighting triad. +# +# Encoder instances take a Tokens object and do something with it. +# +# The most common Encoder is surely the HTML encoder +# (CodeRay::Encoders::HTML). It highlights the code in a colorful +# html page. +# If you want the highlighted code in a div or a span instead, +# use its subclasses Div and Span. +# +# source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:16 +class CodeRay::Encoders::Encoder + extend ::CodeRay::Plugin + + # Creates a new Encoder. + # +options+ is saved and used for all encode operations, as long + # as you don't overwrite it there by passing additional options. + # + # Encoder objects provide three encode methods: + # - encode simply takes a +code+ string and a +lang+ + # - encode_tokens expects a +tokens+ object instead + # + # Each method has an optional +options+ parameter. These are + # added to the options you passed at creation. + # + # @return [Encoder] a new instance of Encoder + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:55 + def initialize(options = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:87 + def <<(token); end + + # Starts a token group with the given +kind+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:123 + def begin_group(kind); end + + # Starts a new line token group with the given +kind+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:131 + def begin_line(kind); end + + # Encode the given +code+ using the Scanner for +lang+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:70 + def encode(code, lang, options = T.unsafe(nil)); end + + # Encode a Tokens object. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:61 + def encode_tokens(tokens, options = T.unsafe(nil)); end + + # Ends a token group with the given +kind+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:127 + def end_group(kind); end + + # Ends a new line token group with the given +kind+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:135 + def end_line(kind); end + + # The default file extension for this encoder. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:83 + def file_extension; end + + # Encode the given +code+ using the Scanner for +lang+. + # You can use highlight instead of encode, if that seems + # more clear to you. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:70 + def highlight(code, lang, options = T.unsafe(nil)); end + + # The options you gave the Encoder at creating. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:43 + def options; end + + # The options you gave the Encoder at creating. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:43 + def options=(_arg0); end + + # The options you gave the Encoder at creating. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:43 + def scanner; end + + # The options you gave the Encoder at creating. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:43 + def scanner=(_arg0); end + + # Called for each text token ([text, kind]), where text is a String. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:118 + def text_token(text, kind); end + + # Called with +content+ and +kind+ of the currently scanned token. + # For simple scanners, it's enougth to implement this method. + # + # By default, it calls text_token, begin_group, end_group, begin_line, + # or end_line, depending on the +content+. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:100 + def token(content, kind); end + + # Do the encoding. + # + # The already created +tokens+ object must be used; it must be a + # Tokens object. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:168 + def tokens(tokens, options = T.unsafe(nil)); end + + protected + + # Do the encoding. + # + # The already created +tokens+ object must be used; it must be a + # Tokens object. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:168 + def compile(tokens, options = T.unsafe(nil)); end + + # Called with merged options after encoding starts. + # The return value is the result of encoding, typically @out. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:160 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:148 + def get_output(options); end + + # Append data.to_s to the output. Returns the argument. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:153 + def output(data); end + + # Called with merged options before encoding starts. + # Sets @out to an empty string. + # + # See the HTML Encoder for an example of option caching. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:144 + def setup(options); end + + class << self + # If FILE_EXTENSION isn't defined, this method returns the + # downcase class name instead. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:24 + def const_missing(sym); end + + # The default file extension for output file of this encoder class. + # + # source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:33 + def file_extension; end + end +end + +# Subclasses are to store their default options in this constant. +# +# source://coderay-1.1.3/lib/coderay/encoders/encoder.rb:40 +CodeRay::Encoders::Encoder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:41 +CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders + +# A Filter encoder has another Tokens instance as output. +# It can be subclass to select, remove, or modify tokens in the stream. +# +# Subclasses of Filter are called "Filters" and can be chained. +# +# == Options +# +# === :tokens +# +# The Tokens object which will receive the output. +# +# Default: Tokens.new +# +# See also: TokenKindFilter +# +# source://coderay-1.1.3/lib/coderay/encoders/filter.rb:18 +class CodeRay::Encoders::Filter < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:39 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:43 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:47 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:51 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:35 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:29 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/filter.rb:23 + def setup(options); end +end + +# = HTML Encoder +# +# This is CodeRay's most important highlighter: +# It provides save, fast XHTML generation and CSS support. +# +# == Usage +# +# require 'coderay' +# puts CodeRay.scan('Some /code/', :ruby).html #-> a HTML page +# puts CodeRay.scan('Some /code/', :ruby).html(:wrap => :span) +# #-> Some /code/ +# puts CodeRay.scan('Some /code/', :ruby).span #-> the same +# +# puts CodeRay.scan('Some code', :ruby).html( +# :wrap => nil, +# :line_numbers => :inline, +# :css => :style +# ) +# +# == Options +# +# === :tab_width +# Convert \t characters to +n+ spaces (a number or false.) +# false will keep tab characters untouched. +# +# Default: 8 +# +# === :css +# How to include the styles; can be :class or :style. +# +# Default: :class +# +# === :wrap +# Wrap in :page, :div, :span or nil. +# +# You can also use Encoders::Div and Encoders::Span. +# +# Default: nil +# +# === :title +# +# The title of the HTML page (works only when :wrap is set to :page.) +# +# Default: 'CodeRay output' +# +# === :break_lines +# +# Split multiline blocks at line breaks. +# Forced to true if :line_numbers option is set to :inline. +# +# Default: false +# +# === :line_numbers +# Include line numbers in :table, :inline, or nil (no line numbers) +# +# Default: nil +# +# === :line_number_anchors +# Adds anchors and links to the line numbers. Can be false (off), true (on), +# or a prefix string that will be prepended to the anchor name. +# +# The prefix must consist only of letters, digits, and underscores. +# +# Default: true, default prefix name: "line" +# +# === :line_number_start +# Where to start with line number counting. +# +# Default: 1 +# +# === :bold_every +# Make every +n+-th number appear bold. +# +# Default: 10 +# +# === :highlight_lines +# +# Highlights certain line numbers. +# Can be any Enumerable, typically just an Array or Range, of numbers. +# +# Bolding is deactivated when :highlight_lines is set. It only makes sense +# in combination with :line_numbers. +# +# Default: nil +# +# === :hint +# Include some information into the output using the title attribute. +# Can be :info (show token kind on mouse-over), :info_long (with full path) +# or :debug (via inspect). +# +# Default: false +# +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:97 +class CodeRay::Encoders::HTML < ::CodeRay::Encoders::Encoder + # token groups, eg. strings + # + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:235 + def begin_group(kind); end + + # whole lines to be highlighted, eg. a deleted line in a diff + # + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:247 + def begin_line(kind); end + + # Returns the value of attribute css. + # + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:126 + def css; end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:241 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:261 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:221 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:316 + def break_lines(text, style); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:310 + def check_group_nesting(name, kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:268 + def check_options!(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:324 + def close_span; end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:280 + def css_class_for_kinds(kinds); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:195 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:289 + def make_span_for_kinds(method, hint); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:172 + def setup(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:284 + def style_for_kinds(kinds); end + + class << self + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:130 + def make_html_escape_hash; end + + # Generate a hint about the given +kinds+ in a +hint+ style. + # + # +hint+ may be :info, :info_long or :debug. + # + # source://coderay-1.1.3/lib/coderay/encoders/html.rb:157 + def token_path_to_hint(hint, kinds); end + end +end + +# source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:5 +class CodeRay::Encoders::HTML::CSS + # @return [CSS] a new instance of CSS + # + # source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:13 + def initialize(style = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:23 + def get_style_for_css_classes(css_classes); end + + # Returns the value of attribute stylesheet. + # + # source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:7 + def stylesheet; end + + private + + # source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:49 + def parse(stylesheet); end + + class << self + # source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:9 + def load_stylesheet(style = T.unsafe(nil)); end + end +end + +# source://coderay-1.1.3/lib/coderay/encoders/html/css.rb:36 +CodeRay::Encoders::HTML::CSS::CSS_CLASS_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:103 +CodeRay::Encoders::HTML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:101 +CodeRay::Encoders::HTML::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:143 +CodeRay::Encoders::HTML::HTML_ESCAPE = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:144 +CodeRay::Encoders::HTML::HTML_ESCAPE_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/encoders/html/numbering.rb:6 +module CodeRay::Encoders::HTML::Numbering + class << self + # source://coderay-1.1.3/lib/coderay/encoders/html/numbering.rb:8 + def number!(output, mode = T.unsafe(nil), options = T.unsafe(nil)); end + end +end + +# This module is included in the output String of the HTML Encoder. +# +# It provides methods like wrap, div, page etc. +# +# Remember to use #clone instead of #dup to keep the modules the object was +# extended with. +# +# TODO: Rewrite this without monkey patching. +# +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:14 +module CodeRay::Encoders::HTML::Output + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:57 + def apply_title!(title); end + + # Returns the value of attribute css. + # + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:16 + def css; end + + # Sets the attribute css + # + # @param value the value to set the attribute css to. + # + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:16 + def css=(_arg0); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:86 + def stylesheet(in_tag = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:62 + def wrap!(element, *args); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:52 + def wrap_in!(template); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:47 + def wrapped_in; end + + # Sets the attribute wrapped_in + # + # @param value the value to set the attribute wrapped_in to. + # + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:50 + def wrapped_in=(_arg0); end + + # @return [Boolean] + # + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:43 + def wrapped_in?(element); end + + class << self + # Raises an exception if an object that doesn't respond to to_str is extended by Output, + # to prevent users from misuse. Use Module#remove_method to disable. + # + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:22 + def extended(o); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:26 + def make_stylesheet(css, in_tag = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:36 + def page_template_for_css(css); end + end +end + +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:117 +CodeRay::Encoders::HTML::Output::DIV = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template) + +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:130 +CodeRay::Encoders::HTML::Output::PAGE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template) + +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:115 +CodeRay::Encoders::HTML::Output::SPAN = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template) + +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:123 +CodeRay::Encoders::HTML::Output::TABLE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template) + +# -- don't include the templates in docu +# +# source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:92 +class CodeRay::Encoders::HTML::Output::Template < ::String + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:104 + def apply(target, replacement); end + + class << self + # source://coderay-1.1.3/lib/coderay/encoders/html/output.rb:94 + def wrap!(str, template, target); end + end +end + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:146 +CodeRay::Encoders::HTML::TOKEN_KIND_TO_INFO = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/html.rb:150 +CodeRay::Encoders::HTML::TRANSPARENT_TOKEN_KINDS = T.let(T.unsafe(nil), Set) + +# A simple JSON Encoder. +# +# Example: +# CodeRay.scan('puts "Hello world!"', :ruby).json +# yields +# [ +# {"type"=>"text", "text"=>"puts", "kind"=>"ident"}, +# {"type"=>"text", "text"=>" ", "kind"=>"space"}, +# {"type"=>"block", "action"=>"open", "kind"=>"string"}, +# {"type"=>"text", "text"=>"\"", "kind"=>"delimiter"}, +# {"type"=>"text", "text"=>"Hello world!", "kind"=>"content"}, +# {"type"=>"text", "text"=>"\"", "kind"=>"delimiter"}, +# {"type"=>"block", "action"=>"close", "kind"=>"string"}, +# ] +# +# source://coderay-1.1.3/lib/coderay/encoders/json.rb:18 +class CodeRay::Encoders::JSON < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:64 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:72 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:68 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:76 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:60 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:49 + def append(data); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:45 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/json.rb:38 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/json.rb:35 +CodeRay::Encoders::JSON::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# Counts the LoC (Lines of Code). Returns an Integer >= 0. +# +# Alias: +loc+ +# +# Everything that is not comment, markup, doctype/shebang, or an empty line, +# is considered to be code. +# +# For example, +# * HTML files not containing JavaScript have 0 LoC +# * in a Java class without comments, LoC is the number of non-empty lines +# +# A Scanner class should define the token kinds that are not code in the +# KINDS_NOT_LOC constant, which defaults to [:comment, :doctype]. +# +# source://coderay-1.1.3/lib/coderay/encoders/lines_of_code.rb:17 +class CodeRay::Encoders::LinesOfCode < ::CodeRay::Encoders::TokenKindFilter + protected + + # source://coderay-1.1.3/lib/coderay/encoders/lines_of_code.rb:38 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/lines_of_code.rb:25 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/lines_of_code.rb:21 +CodeRay::Encoders::LinesOfCode::NON_EMPTY_LINE = T.let(T.unsafe(nil), Regexp) + +# = Lint Encoder +# +# Checks for: +# +# - empty tokens +# - incorrect nesting +# +# It will raise an InvalidTokenStream exception when any of the above occurs. +# +# See also: Encoders::DebugLint +# +# source://coderay-1.1.3/lib/coderay/encoders/lint.rb:14 +class CodeRay::Encoders::Lint < ::CodeRay::Encoders::Debug + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:28 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:37 + def begin_line(kind); end + + # @raise [IncorrectTokenGroupNesting] + # + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:32 + def end_group(kind); end + + # @raise [IncorrectTokenGroupNesting] + # + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:41 + def end_line(kind); end + + # @raise [EmptyToken] + # + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:23 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:52 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/lint.rb:48 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/lint.rb:19 +class CodeRay::Encoders::Lint::EmptyToken < ::CodeRay::Encoders::Lint::InvalidTokenStream; end + +# source://coderay-1.1.3/lib/coderay/encoders/lint.rb:21 +class CodeRay::Encoders::Lint::IncorrectTokenGroupNesting < ::CodeRay::Encoders::Lint::InvalidTokenStream; end + +# source://coderay-1.1.3/lib/coderay/encoders/lint.rb:18 +class CodeRay::Encoders::Lint::InvalidTokenStream < ::StandardError; end + +# source://coderay-1.1.3/lib/coderay/encoders/lint.rb:20 +class CodeRay::Encoders::Lint::UnknownTokenKind < ::CodeRay::Encoders::Lint::InvalidTokenStream; end + +# = Null Encoder +# +# Does nothing and returns an empty string. +# +# source://coderay-1.1.3/lib/coderay/encoders/null.rb:7 +class CodeRay::Encoders::Null < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/null.rb:11 + def text_token(text, kind); end +end + +# Wraps the output into a HTML page, using CSS classes and +# line numbers in the table format by default. +# +# See Encoders::HTML for available options. +# +# source://coderay-1.1.3/lib/coderay/encoders/page.rb:10 +class CodeRay::Encoders::Page < ::CodeRay::Encoders::HTML; end + +# source://coderay-1.1.3/lib/coderay/encoders/page.rb:16 +CodeRay::Encoders::Page::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/page.rb:12 +CodeRay::Encoders::Page::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# Wraps HTML output into a SPAN element, using inline styles by default. +# +# See Encoders::HTML for available options. +# +# source://coderay-1.1.3/lib/coderay/encoders/span.rb:9 +class CodeRay::Encoders::Span < ::CodeRay::Encoders::HTML; end + +# source://coderay-1.1.3/lib/coderay/encoders/span.rb:15 +CodeRay::Encoders::Span::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/span.rb:11 +CodeRay::Encoders::Span::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# Makes a statistic for the given tokens. +# +# Alias: +stats+ +# +# source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:7 +class CodeRay::Encoders::Statistic < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:70 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:78 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:86 + def block_token(action, kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:74 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:82 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:11 + def real_token_count; end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:62 + def text_token(text, kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:11 + def type_stats; end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:42 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:17 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:24 +CodeRay::Encoders::Statistic::STATS = T.let(T.unsafe(nil), String) + +# source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:38 +CodeRay::Encoders::Statistic::TOKEN_TYPES_ROW = T.let(T.unsafe(nil), String) + +# source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:13 +class CodeRay::Encoders::Statistic::TypeStats < ::Struct + # Returns the value of attribute count + # + # @return [Object] the current value of count + def count; end + + # Sets the attribute count + # + # @param value [Object] the value to set the attribute count to. + # @return [Object] the newly set value + # + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:13 + def count=(_); end + + # Returns the value of attribute size + # + # @return [Object] the current value of size + def size; end + + # Sets the attribute size + # + # @param value [Object] the value to set the attribute size to. + # @return [Object] the newly set value + # + # source://coderay-1.1.3/lib/coderay/encoders/statistic.rb:13 + def size=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:17 +class CodeRay::Encoders::Terminal < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:156 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:156 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:162 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:172 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:141 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:133 + def setup(options); end + + private + + # source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:179 + def open_token(kind); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/terminal.rb:21 +CodeRay::Encoders::Terminal::TOKEN_COLORS = T.let(T.unsafe(nil), Hash) + +# Concats the tokens into a single string, resulting in the original +# code string if no tokens were removed. +# +# Alias: +plain+, +plaintext+ +# +# == Options +# +# === :separator +# A separator string to join the tokens. +# +# Default: empty String +# +# source://coderay-1.1.3/lib/coderay/encoders/text.rb:15 +class CodeRay::Encoders::Text < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/text.rb:25 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/text.rb:36 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/text.rb:21 +CodeRay::Encoders::Text::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/text.rb:19 +CodeRay::Encoders::Text::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# A Filter that selects tokens based on their token kind. +# +# == Options +# +# === :exclude +# +# One or many symbols (in an Array) which shall be excluded. +# +# Default: [] +# +# === :include +# +# One or many symbols (in an array) which shall be included. +# +# Default: :all, which means all tokens are included. +# +# Exclusion wins over inclusion. +# +# See also: CommentFilter +# +# source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:25 +class CodeRay::Encoders::TokenKindFilter < ::CodeRay::Encoders::Filter + # Add the token group to the output stream if +kind+ matches the + # conditions. + # + # If it does not, all tokens inside the group are excluded from the + # stream, even if their kinds match. + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:66 + def begin_group(kind); end + + # See +begin_group+. + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:77 + def begin_line(kind); end + + # Take care of re-enabling the delegation of tokens to the output stream + # if an exluded group has ended. + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:89 + def end_group(kind); end + + # See +end_group+. + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:99 + def end_line(kind); end + + # Add the token to the output stream if +kind+ matches the conditions. + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:57 + def text_token(text, kind); end + + protected + + # @return [Boolean] + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:49 + def include_group?(kind); end + + # @return [Boolean] + # + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:45 + def include_text_token?(text, kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:35 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/token_kind_filter.rb:29 +CodeRay::Encoders::TokenKindFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# = XML Encoder +# +# Uses REXML. Very slow. +# +# source://coderay-1.1.3/lib/coderay/encoders/xml.rb:7 +class CodeRay::Encoders::XML < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/xml.rb:58 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/xml.rb:62 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/xml.rb:38 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/xml.rb:31 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/xml.rb:22 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/xml.rb:15 +CodeRay::Encoders::XML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/encoders/xml.rb:11 +CodeRay::Encoders::XML::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# = YAML Encoder +# +# Slow. +# +# source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:9 +class CodeRay::Encoders::YAML < ::CodeRay::Encoders::Encoder + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:31 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:39 + def begin_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:35 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:43 + def end_line(kind); end + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:27 + def text_token(text, kind); end + + protected + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:22 + def finish(options); end + + # source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:16 + def setup(options); end +end + +# source://coderay-1.1.3/lib/coderay/encoders/yaml.rb:13 +CodeRay::Encoders::YAML::FILE_EXTENSION = T.let(T.unsafe(nil), String) + +# = FileType +# +# A simple filetype recognizer. +# +# == Usage +# +# # determine the type of the given +# lang = FileType[file_name] +# +# # return :text if the file type is unknown +# lang = FileType.fetch file_name, :text +# +# # try the shebang line, too +# lang = FileType.fetch file_name, :text, true +# +# source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:17 +module CodeRay::FileType + class << self + # Try to determine the file type of the file. + # + # +filename+ is a relative or absolute path to a file. + # + # The file itself is only accessed when +read_shebang+ is set to true. + # That means you can get filetypes from files that don't exist. + # + # source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:29 + def [](filename, read_shebang = T.unsafe(nil)); end + + # This works like Hash#fetch. + # + # If the filetype cannot be found, the +default+ value + # is returned. + # + # source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:50 + def fetch(filename, default = T.unsafe(nil), read_shebang = T.unsafe(nil)); end + + protected + + # source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:66 + def type_from_shebang(filename); end + end +end + +# source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:79 +CodeRay::FileType::TypeFromExt = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:139 +CodeRay::FileType::TypeFromName = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:137 +CodeRay::FileType::TypeFromShebang = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/helpers/file_type.rb:19 +class CodeRay::FileType::UnknownFileType < ::Exception; end + +# = Plugin +# +# Plugins have to include this module. +# +# IMPORTANT: Use extend for this module. +# +# See CodeRay::PluginHost for examples. +# +# source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:10 +module CodeRay::Plugin + # source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:46 + def aliases; end + + # The PluginHost for this Plugin class. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:39 + def plugin_host(host = T.unsafe(nil)); end + + # Returns the value of attribute plugin_id. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:12 + def plugin_id; end + + # Register this class for the given +id+. + # + # Example: + # class MyPlugin < PluginHost::BaseClass + # register_for :my_id + # ... + # end + # + # See PluginHost.register. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:23 + def register_for(id); end + + # Returns the title of the plugin, or sets it to the + # optional argument +title+. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:30 + def title(title = T.unsafe(nil)); end +end + +# = PluginHost +# +# A simple subclass/subfolder plugin system. +# +# Example: +# class Generators +# extend PluginHost +# plugin_path 'app/generators' +# end +# +# class Generator +# extend Plugin +# PLUGIN_HOST = Generators +# end +# +# class FancyGenerator < Generator +# register_for :fancy +# end +# +# Generators[:fancy] #-> FancyGenerator +# # or +# CodeRay.require_plugin 'Generators/fancy' +# # or +# Generators::Fancy +# +# source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:27 +module CodeRay::PluginHost + # Returns the Plugin for +id+. + # + # Example: + # yaml_plugin = MyPluginHost[:yaml] + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:49 + def [](id, *args, &blk); end + + # Returns an array of all Plugins. + # + # Note: This loads all plugins using load_all. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:151 + def all_plugins; end + + # Tries to +load+ the missing plugin by translating +const+ to the + # underscore form (eg. LinesOfCode becomes lines_of_code). + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:61 + def const_missing(const); end + + # Define the default plugin to use when no plugin is found + # for a given id, or return the default plugin. + # + # See also map. + # + # class MyColorHost < PluginHost + # map :navy => :dark_blue + # default :gray + # end + # + # MyColorHost.default # loads and returns the Gray plugin + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:114 + def default(id = T.unsafe(nil)); end + + # Returns an array of all .rb files in the plugin path. + # + # The extension .rb is not included. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:140 + def list; end + + # Returns the Plugin for +id+. + # + # Example: + # yaml_plugin = MyPluginHost[:yaml] + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:49 + def load(id, *args, &blk); end + + # Loads all plugins using list and load. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:39 + def load_all; end + + # Loads the map file (see map). + # + # This is done automatically when plugin_path is called. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:159 + def load_plugin_map; end + + # Map a plugin_id to another. + # + # Usage: Put this in a file plugin_path/_map.rb. + # + # class MyColorHost < PluginHost + # map :navy => :dark_blue, + # :maroon => :brown, + # :luna => :moon + # end + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:95 + def map(hash); end + + # A Hash of plugion_id => Plugin pairs. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:133 + def plugin_hash; end + + # The path where the plugins can be found. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:79 + def plugin_path(*args); end + + # Every plugin must register itself for +id+ by calling register_for, + # which calls this method. + # + # See Plugin#register_for. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:128 + def register(plugin, id); end + + protected + + # Return a plugin hash that automatically loads plugins. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:172 + def make_plugin_hash; end + + # Returns the expected path to the plugin file for the given id. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:196 + def path_to(plugin_id); end + + # Converts +id+ to a valid plugin ID String, or returns +nil+. + # + # Raises +ArgumentError+ for all other objects, or if the + # given String includes non-alphanumeric characters (\W). + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:204 + def validate_id(id); end + + class << self + # Adds the module/class to the PLUGIN_HOSTS list. + # + # source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:72 + def extended(mod); end + end +end + +# source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:33 +class CodeRay::PluginHost::HostNotFound < ::LoadError; end + +# source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:35 +CodeRay::PluginHost::PLUGIN_HOSTS = T.let(T.unsafe(nil), Array) + +# dummy hash +# +# source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:36 +CodeRay::PluginHost::PLUGIN_HOSTS_BY_ID = T.let(T.unsafe(nil), Hash) + +# Raised if Encoders::[] fails because: +# * a file could not be found +# * the requested Plugin is not registered +# +# source://coderay-1.1.3/lib/coderay/helpers/plugin_host.rb:32 +class CodeRay::PluginHost::PluginNotFound < ::LoadError; end + +# = Scanners +# +# This module holds the Scanner class and its subclasses. +# For example, the Ruby scanner is named CodeRay::Scanners::Ruby +# can be found in coderay/scanners/ruby. +# +# Scanner also provides methods and constants for the register +# mechanism and the [] method that returns the Scanner class +# belonging to the given lang. +# +# See PluginHost. +# +# source://coderay-1.1.3/lib/coderay/scanners.rb:18 +module CodeRay::Scanners + extend ::CodeRay::PluginHost +end + +# Scanner for C. +# +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:5 +class CodeRay::Scanners::C < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/c.rb:44 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:27 +CodeRay::Scanners::C::DIRECTIVES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:39 +CodeRay::Scanners::C::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:33 +CodeRay::Scanners::C::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:10 +CodeRay::Scanners::C::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:23 +CodeRay::Scanners::C::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:17 +CodeRay::Scanners::C::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/c.rb:40 +CodeRay::Scanners::C::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Scanner for C++. +# +# Aliases: +cplusplus+, c++ +CodeRay::Scanners::CPlusPlus = CodeRay::Scanners::Text + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:4 +class CodeRay::Scanners::CSS < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/css.rb:55 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/css.rb:50 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:8 +CodeRay::Scanners::CSS::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:16 +module CodeRay::Scanners::CSS::RE; end + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:31 +CodeRay::Scanners::CSS::RE::AtKeyword = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:45 +CodeRay::Scanners::CSS::RE::AttributeSelector = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:43 +CodeRay::Scanners::CSS::RE::Class = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:38 +CodeRay::Scanners::CSS::RE::Dimension = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:19 +CodeRay::Scanners::CSS::RE::Escape = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:40 +CodeRay::Scanners::CSS::RE::Function = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:17 +CodeRay::Scanners::CSS::RE::Hex = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:26 +CodeRay::Scanners::CSS::RE::HexColor = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:42 +CodeRay::Scanners::CSS::RE::Id = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:30 +CodeRay::Scanners::CSS::RE::Ident = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:20 +CodeRay::Scanners::CSS::RE::NMChar = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:21 +CodeRay::Scanners::CSS::RE::NMStart = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:29 +CodeRay::Scanners::CSS::RE::Name = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:28 +CodeRay::Scanners::CSS::RE::Num = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:32 +CodeRay::Scanners::CSS::RE::Percentage = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:44 +CodeRay::Scanners::CSS::RE::PseudoClass = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:24 +CodeRay::Scanners::CSS::RE::String = T.let(T.unsafe(nil), Regexp) + +# TODO: buggy regexp +# +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:22 +CodeRay::Scanners::CSS::RE::String1 = T.let(T.unsafe(nil), Regexp) + +# TODO: buggy regexp +# +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:23 +CodeRay::Scanners::CSS::RE::String2 = T.let(T.unsafe(nil), Regexp) + +# differs from standard because it allows uppercase hex too +# +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:18 +CodeRay::Scanners::CSS::RE::Unicode = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/css.rb:36 +CodeRay::Scanners::CSS::RE::Unit = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:6 +class CodeRay::Scanners::Clojure < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:145 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:95 +CodeRay::Scanners::Clojure::BASIC_IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:133 +CodeRay::Scanners::Clojure::COMPLEX10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:134 +CodeRay::Scanners::Clojure::COMPLEX16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:136 +CodeRay::Scanners::Clojure::COMPLEX2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:135 +CodeRay::Scanners::Clojure::COMPLEX8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:16 +CodeRay::Scanners::Clojure::CORE_FORMS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:120 +CodeRay::Scanners::Clojure::DECIMAL = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:98 +CodeRay::Scanners::Clojure::DIGIT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:99 +CodeRay::Scanners::Clojure::DIGIT10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:100 +CodeRay::Scanners::Clojure::DIGIT16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:102 +CodeRay::Scanners::Clojure::DIGIT2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:101 +CodeRay::Scanners::Clojure::DIGIT8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:107 +CodeRay::Scanners::Clojure::EXACTNESS = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:110 +CodeRay::Scanners::Clojure::EXP = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:109 +CodeRay::Scanners::Clojure::EXP_MARK = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:96 +CodeRay::Scanners::Clojure::IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:85 +CodeRay::Scanners::Clojure::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:129 +CodeRay::Scanners::Clojure::IMAG10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:130 +CodeRay::Scanners::Clojure::IMAG16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:132 +CodeRay::Scanners::Clojure::IMAG2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:131 +CodeRay::Scanners::Clojure::IMAG8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:90 +CodeRay::Scanners::Clojure::KEYWORD_NEXT_TOKEN_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:141 +CodeRay::Scanners::Clojure::NUM = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:137 +CodeRay::Scanners::Clojure::NUM10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:138 +CodeRay::Scanners::Clojure::NUM16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:140 +CodeRay::Scanners::Clojure::NUM2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:139 +CodeRay::Scanners::Clojure::NUM8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:78 +CodeRay::Scanners::Clojure::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:112 +CodeRay::Scanners::Clojure::PREFIX10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:113 +CodeRay::Scanners::Clojure::PREFIX16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:115 +CodeRay::Scanners::Clojure::PREFIX2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:114 +CodeRay::Scanners::Clojure::PREFIX8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:106 +CodeRay::Scanners::Clojure::RADIX10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:103 +CodeRay::Scanners::Clojure::RADIX16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:105 +CodeRay::Scanners::Clojure::RADIX2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:104 +CodeRay::Scanners::Clojure::RADIX8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:125 +CodeRay::Scanners::Clojure::REAL10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:126 +CodeRay::Scanners::Clojure::REAL16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:128 +CodeRay::Scanners::Clojure::REAL2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:127 +CodeRay::Scanners::Clojure::REAL8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:108 +CodeRay::Scanners::Clojure::SIGN = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:11 +CodeRay::Scanners::Clojure::SPECIAL_FORMS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:111 +CodeRay::Scanners::Clojure::SUFFIX = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:97 +CodeRay::Scanners::Clojure::SYMBOL = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:116 +CodeRay::Scanners::Clojure::UINT10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:117 +CodeRay::Scanners::Clojure::UINT16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:119 +CodeRay::Scanners::Clojure::UINT2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:118 +CodeRay::Scanners::Clojure::UINT8 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:121 +CodeRay::Scanners::Clojure::UREAL10 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:122 +CodeRay::Scanners::Clojure::UREAL16 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:124 +CodeRay::Scanners::Clojure::UREAL2 = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/clojure.rb:123 +CodeRay::Scanners::Clojure::UREAL8 = T.let(T.unsafe(nil), Regexp) + +# = Debug Scanner +# +# Interprets the output of the Encoders::Debug encoder (basically the inverse function). +# +# source://coderay-1.1.3/lib/coderay/scanners/debug.rb:9 +class CodeRay::Scanners::Debug < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/debug.rb:21 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/debug.rb:16 + def setup; end +end + +# Scanner for the Delphi language (Object Pascal). +# +# Alias: +pascal+ +# +# source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:7 +class CodeRay::Scanners::Delphi < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:45 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:25 +CodeRay::Scanners::Delphi::DIRECTIVES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:36 +CodeRay::Scanners::Delphi::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring) + +# source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:12 +CodeRay::Scanners::Delphi::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/delphi.rb:40 +CodeRay::Scanners::Delphi::NAME_FOLLOWS = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring) + +# Scanner for output of the diff command. +# +# Alias: +patch+ +# +# source://coderay-1.1.3/lib/coderay/scanners/diff.rb:7 +class CodeRay::Scanners::Diff < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/diff.rb:19 + def scan_tokens(encoder, options); end + + private + + # source://coderay-1.1.3/lib/coderay/scanners/diff.rb:204 + def diff(a, b); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/diff.rb:12 +CodeRay::Scanners::Diff::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# Scanner for HTML ERB templates. +# +# source://coderay-1.1.3/lib/coderay/scanners/erb.rb:8 +class CodeRay::Scanners::ERB < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/erb.rb:38 + def reset_instance; end + + # source://coderay-1.1.3/lib/coderay/scanners/erb.rb:43 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/erb.rb:33 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/erb.rb:15 +CodeRay::Scanners::ERB::ERB_RUBY_BLOCK = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/erb.rb:13 +CodeRay::Scanners::ERB::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/erb.rb:27 +CodeRay::Scanners::ERB::START_OF_ERB = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:4 +class CodeRay::Scanners::Go < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/go.rb:50 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:45 +CodeRay::Scanners::Go::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:39 +CodeRay::Scanners::Go::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# http://golang.org/ref/spec#Keywords +# +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:10 +CodeRay::Scanners::Go::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:29 +CodeRay::Scanners::Go::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:34 +CodeRay::Scanners::Go::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array) + +# http://golang.org/ref/spec#Types +# +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:19 +CodeRay::Scanners::Go::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/go.rb:46 +CodeRay::Scanners::Go::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Scanner for Groovy. +# +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:7 +class CodeRay::Scanners::Groovy < ::CodeRay::Scanners::Java + protected + + # source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:43 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:39 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:24 +CodeRay::Scanners::Groovy::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# TODO: check list of keywords +# +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:12 +CodeRay::Scanners::Groovy::GROOVY_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:18 +CodeRay::Scanners::Groovy::GROOVY_MAGIC_VARIABLES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:20 +CodeRay::Scanners::Groovy::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:15 +CodeRay::Scanners::Groovy::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:26 +CodeRay::Scanners::Groovy::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# TODO: interpretation inside ', ", / +# +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:29 +CodeRay::Scanners::Groovy::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/groovy.rb:25 +CodeRay::Scanners::Groovy::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/haml.rb:8 +class CodeRay::Scanners::HAML < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/haml.rb:24 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/haml.rb:17 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/haml.rb:13 +CodeRay::Scanners::HAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# HTML Scanner +# +# Alias: +xhtml+ +# +# See also: Scanners::XML +# +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:9 +class CodeRay::Scanners::HTML < ::CodeRay::Scanners::Scanner + # source://coderay-1.1.3/lib/coderay/scanners/html.rb:62 + def reset; end + + protected + + # source://coderay-1.1.3/lib/coderay/scanners/html.rb:83 + def scan_css(encoder, code, state = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/scanners/html.rb:76 + def scan_java_script(encoder, code); end + + # source://coderay-1.1.3/lib/coderay/scanners/html.rb:90 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/html.rb:70 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:39 +CodeRay::Scanners::HTML::ATTR_NAME = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:42 +CodeRay::Scanners::HTML::ENTITY = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:20 +CodeRay::Scanners::HTML::EVENT_ATTRIBUTES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:41 +CodeRay::Scanners::HTML::HEX = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:35 +CodeRay::Scanners::HTML::IN_ATTRIBUTE = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:13 +CodeRay::Scanners::HTML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:57 +CodeRay::Scanners::HTML::PLAIN_STRING_CONTENT = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/html.rb:40 +CodeRay::Scanners::HTML::TAG_END = T.let(T.unsafe(nil), Regexp) + +# Scanner for JSON (JavaScript Object Notation). +# +# source://coderay-1.1.3/lib/coderay/scanners/json.rb:5 +class CodeRay::Scanners::JSON < ::CodeRay::Scanners::Scanner + protected + + # See http://json.org/ for a definition of the JSON lexic/grammar. + # + # source://coderay-1.1.3/lib/coderay/scanners/json.rb:26 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/json.rb:21 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/json.rb:15 +CodeRay::Scanners::JSON::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/json.rb:17 +CodeRay::Scanners::JSON::KEY = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/json.rb:10 +CodeRay::Scanners::JSON::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/json.rb:16 +CodeRay::Scanners::JSON::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Scanner for Java. +# +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:5 +class CodeRay::Scanners::Java < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/java.rb:51 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/java/builtin_types.rb:4 +module CodeRay::Scanners::Java::BuiltinTypes; end + +# source://coderay-1.1.3/lib/coderay/scanners/java/builtin_types.rb:7 +CodeRay::Scanners::Java::BuiltinTypes::List = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:19 +CodeRay::Scanners::Java::CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:25 +CodeRay::Scanners::Java::DIRECTIVES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:40 +CodeRay::Scanners::Java::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:47 +CodeRay::Scanners::Java::IDENT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:30 +CodeRay::Scanners::Java::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html +# +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:12 +CodeRay::Scanners::Java::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:20 +CodeRay::Scanners::Java::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:18 +CodeRay::Scanners::Java::RESERVED = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:42 +CodeRay::Scanners::Java::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:21 +CodeRay::Scanners::Java::TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java.rb:41 +CodeRay::Scanners::Java::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Scanner for JavaScript. +# +# Aliases: +ecmascript+, +ecma_script+, +javascript+ +# +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:7 +class CodeRay::Scanners::JavaScript < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:224 + def reset_instance; end + + # source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:61 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:57 + def setup; end + + # source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:229 + def xml_scanner; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:42 +CodeRay::Scanners::JavaScript::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:36 +CodeRay::Scanners::JavaScript::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# The actual JavaScript keywords. +# +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:13 +CodeRay::Scanners::JavaScript::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:24 +CodeRay::Scanners::JavaScript::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:50 +CodeRay::Scanners::JavaScript::KEY_CHECK_PATTERN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:22 +CodeRay::Scanners::JavaScript::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:18 +CodeRay::Scanners::JavaScript::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:44 +CodeRay::Scanners::JavaScript::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Reserved for future use. +# +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:29 +CodeRay::Scanners::JavaScript::RESERVED_WORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:45 +CodeRay::Scanners::JavaScript::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/java_script.rb:43 +CodeRay::Scanners::JavaScript::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# Scanner for the Lua[http://lua.org] programming lanuage. +# +# The language’s complete syntax is defined in +# {the Lua manual}[http://www.lua.org/manual/5.2/manual.html], +# which is what this scanner tries to conform to. +# +# source://coderay-1.1.3/lib/coderay/scanners/lua.rb:11 +class CodeRay::Scanners::Lua < ::CodeRay::Scanners::Scanner + protected + + # CodeRay entry hook. Starts parsing. + # + # source://coderay-1.1.3/lib/coderay/scanners/lua.rb:60 + def scan_tokens(encoder, options); end + + # Scanner initialization. + # + # source://coderay-1.1.3/lib/coderay/scanners/lua.rb:54 + def setup; end +end + +# Automatic token kind selection for normal words. +# +# source://coderay-1.1.3/lib/coderay/scanners/lua.rb:46 +CodeRay::Scanners::Lua::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# Keywords used in Lua. +# +# source://coderay-1.1.3/lib/coderay/scanners/lua.rb:18 +CodeRay::Scanners::Lua::KEYWORDS = T.let(T.unsafe(nil), Array) + +# Constants set by the Lua core. +# +# source://coderay-1.1.3/lib/coderay/scanners/lua.rb:25 +CodeRay::Scanners::Lua::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# The expressions contained in this array are parts of Lua’s `basic' +# library. Although it’s not entirely necessary to load that library, +# it is highly recommended and one would have to provide own implementations +# of some of these expressions if one does not do so. They however aren’t +# keywords, neither are they constants, but nearly predefined, so they +# get tagged as `predefined' rather than anything else. +# +# This list excludes values of form `_UPPERCASE' because the Lua manual +# requires such identifiers to be reserved by Lua anyway and they are +# highlighted directly accordingly, without the need for specific +# identifiers to be listed here. +# +# source://coderay-1.1.3/lib/coderay/scanners/lua.rb:38 +CodeRay::Scanners::Lua::PREDEFINED_EXPRESSIONS = T.let(T.unsafe(nil), Array) + +# Scanner for PHP. +# +# Original by Stefan Walk. +# +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:10 +class CodeRay::Scanners::PHP < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/php.rb:23 + def reset_instance; end + + # source://coderay-1.1.3/lib/coderay/scanners/php.rb:234 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/php.rb:19 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:15 +CodeRay::Scanners::PHP::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:197 +module CodeRay::Scanners::PHP::RE; end + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:211 +CodeRay::Scanners::PHP::RE::HTML_INDICATOR = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:213 +CodeRay::Scanners::PHP::RE::IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:216 +CodeRay::Scanners::PHP::RE::OPERATOR = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:206 +CodeRay::Scanners::PHP::RE::PHP_END = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:199 +CodeRay::Scanners::PHP::RE::PHP_START = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:214 +CodeRay::Scanners::PHP::RE::VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:28 +module CodeRay::Scanners::PHP::Words; end + +# according to http://php.net/quickref.php on 2009-04-21; +# all functions with _ excluded (module functions) and selected additional functions +# +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:50 +CodeRay::Scanners::PHP::Words::BUILTIN_FUNCTIONS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:46 +CodeRay::Scanners::PHP::Words::CLASSES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:145 +CodeRay::Scanners::PHP::Words::CONSTANTS = T.let(T.unsafe(nil), Array) + +# TODO: more built-in PHP functions? +# +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:140 +CodeRay::Scanners::PHP::Words::EXCEPTIONS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:184 +CodeRay::Scanners::PHP::Words::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring) + +# according to http://www.php.net/manual/en/reserved.keywords.php +# +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:31 +CodeRay::Scanners::PHP::Words::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:41 +CodeRay::Scanners::PHP::Words::LANGUAGE_CONSTRUCTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:178 +CodeRay::Scanners::PHP::Words::PREDEFINED = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:39 +CodeRay::Scanners::PHP::Words::TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/php.rb:193 +CodeRay::Scanners::PHP::Words::VARIABLE_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# Scanner for Python. Supports Python 3. +# +# Based on pygments' PythonLexer, see +# http://dev.pocoo.org/projects/pygments/browser/pygments/lexers/agile.py. +# +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:8 +class CodeRay::Scanners::Python < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/python.rb:103 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:86 +CodeRay::Scanners::Python::DEF_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:91 +CodeRay::Scanners::Python::DESCRIPTOR = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:97 +CodeRay::Scanners::Python::DOCSTRING_COMING = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:65 +CodeRay::Scanners::Python::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:57 +CodeRay::Scanners::Python::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:13 +CodeRay::Scanners::Python::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:64 +CodeRay::Scanners::Python::NAME = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:21 +CodeRay::Scanners::Python::OLD_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:68 +CodeRay::Scanners::Python::OPERATOR = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:37 +CodeRay::Scanners::Python::PREDEFINED_EXCEPTIONS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:25 +CodeRay::Scanners::Python::PREDEFINED_METHODS_AND_TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:52 +CodeRay::Scanners::Python::PREDEFINED_VARIABLES_AND_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:82 +CodeRay::Scanners::Python::STRING_CONTENT_REGEXP = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:78 +CodeRay::Scanners::Python::STRING_DELIMITER_REGEXP = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/python.rb:66 +CodeRay::Scanners::Python::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# = Raydebug Scanner +# +# Highlights the output of the Encoders::Debug encoder. +# +# source://coderay-1.1.3/lib/coderay/scanners/raydebug.rb:9 +class CodeRay::Scanners::Raydebug < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/raydebug.rb:22 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/raydebug.rb:17 + def setup; end +end + +# This scanner is really complex, since Ruby _is_ a complex language! +# +# It tries to highlight 100% of all common code, +# and 90% of strange codes. +# +# It is optimized for HTML highlighting, and is not very useful for +# parsing or pretty printing. +# +# source://coderay-1.1.3/lib/coderay/scanners/ruby.rb:11 +class CodeRay::Scanners::Ruby < ::CodeRay::Scanners::Scanner + # source://coderay-1.1.3/lib/coderay/scanners/ruby.rb:19 + def interpreted_string_state; end + + protected + + # source://coderay-1.1.3/lib/coderay/scanners/ruby.rb:29 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/ruby.rb:25 + def setup; end +end + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:5 +module CodeRay::Scanners::Ruby::Patterns; end + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:72 +CodeRay::Scanners::Ruby::Patterns::BINARY = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:106 +CodeRay::Scanners::Ruby::Patterns::CHARACTER = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:55 +CodeRay::Scanners::Ruby::Patterns::CLASS_VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:96 +CodeRay::Scanners::Ruby::Patterns::CONTROL_META_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:132 +CodeRay::Scanners::Ruby::Patterns::DATA = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:69 +CodeRay::Scanners::Ruby::Patterns::DECIMAL = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:102 +CodeRay::Scanners::Ruby::Patterns::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:74 +CodeRay::Scanners::Ruby::Patterns::EXPONENT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:168 +CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_INTERPRETED = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:161 +CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_KIND = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:160 +CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_START = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:76 +CodeRay::Scanners::Ruby::Patterns::FLOAT_OR_INT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:75 +CodeRay::Scanners::Ruby::Patterns::FLOAT_SUFFIX = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:57 +CodeRay::Scanners::Ruby::Patterns::GLOBAL_VARIABLE = T.let(T.unsafe(nil), Regexp) + +# NOTE: This is not completely correct, but +# nobody needs heredoc delimiters ending with \n. +# +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:116 +CodeRay::Scanners::Ruby::Patterns::HEREDOC_OPEN = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:71 +CodeRay::Scanners::Ruby::Patterns::HEXADECIMAL = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:38 +CodeRay::Scanners::Ruby::Patterns::IDENT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:28 +CodeRay::Scanners::Ruby::Patterns::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:54 +CodeRay::Scanners::Ruby::Patterns::INSTANCE_VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:7 +CodeRay::Scanners::Ruby::Patterns::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:151 +CodeRay::Scanners::Ruby::Patterns::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:32 +CodeRay::Scanners::Ruby::Patterns::KEYWORD_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:53 +CodeRay::Scanners::Ruby::Patterns::METHOD_AFTER_DOT = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:40 +CodeRay::Scanners::Ruby::Patterns::METHOD_NAME = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:52 +CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_EX = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:41 +CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OPERATOR = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:87 +CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OR_SYMBOL = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:51 +CodeRay::Scanners::Ruby::Patterns::METHOD_SUFFIX = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:77 +CodeRay::Scanners::Ruby::Patterns::NUMERIC = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:56 +CodeRay::Scanners::Ruby::Patterns::OBJECT_VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:70 +CodeRay::Scanners::Ruby::Patterns::OCTAL = T.let(T.unsafe(nil), Regexp) + +# See http://murfy.de/ruby-constants. +# +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:17 +CodeRay::Scanners::Ruby::Patterns::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:58 +CodeRay::Scanners::Ruby::Patterns::PREFIX_VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:61 +CodeRay::Scanners::Ruby::Patterns::QUOTE_TO_TYPE = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:67 +CodeRay::Scanners::Ruby::Patterns::REGEXP_MODIFIERS = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:126 +CodeRay::Scanners::Ruby::Patterns::RUBYDOC = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:138 +CodeRay::Scanners::Ruby::Patterns::RUBYDOC_OR_DATA = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:89 +CodeRay::Scanners::Ruby::Patterns::SIMPLE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:79 +CodeRay::Scanners::Ruby::Patterns::SYMBOL = T.let(T.unsafe(nil), Regexp) + +# Checks for a valid value to follow. This enables +# value_expected in method calls without parentheses. +# +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:142 +CodeRay::Scanners::Ruby::Patterns::VALUE_FOLLOWS = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/patterns.rb:59 +CodeRay::Scanners::Ruby::Patterns::VARIABLE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:8 +class CodeRay::Scanners::Ruby::StringState < ::Struct + # @return [StringState] a new instance of StringState + # + # source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:48 + def initialize(kind, interpreted, delim, heredoc = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:63 + def heredoc_pattern(delim, interpreted, indented); end + + class << self + # source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:40 + def simple_key_pattern(delim); end + end +end + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:10 +CodeRay::Scanners::Ruby::StringState::CLOSING_PAREN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/ruby/string_state.rb:17 +CodeRay::Scanners::Ruby::StringState::STRING_PATTERN = T.let(T.unsafe(nil), Hash) + +# by Josh Goebel +# +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:5 +class CodeRay::Scanners::SQL < ::CodeRay::Scanners::Scanner + # source://coderay-1.1.3/lib/coderay/scanners/sql.rb:66 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:23 +CodeRay::Scanners::SQL::COMMANDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:38 +CodeRay::Scanners::SQL::DIRECTIVES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:55 +CodeRay::Scanners::SQL::ESCAPE = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:46 +CodeRay::Scanners::SQL::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:9 +CodeRay::Scanners::SQL::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:18 +CodeRay::Scanners::SQL::OBJECTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:44 +CodeRay::Scanners::SQL::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:36 +CodeRay::Scanners::SQL::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:28 +CodeRay::Scanners::SQL::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:60 +CodeRay::Scanners::SQL::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:58 +CodeRay::Scanners::SQL::STRING_PREFIXES = T.let(T.unsafe(nil), Regexp) + +# source://coderay-1.1.3/lib/coderay/scanners/sql.rb:56 +CodeRay::Scanners::SQL::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp) + +# A scanner for Sass. +# +# source://coderay-1.1.3/lib/coderay/scanners/sass.rb:5 +class CodeRay::Scanners::Sass < ::CodeRay::Scanners::CSS + protected + + # source://coderay-1.1.3/lib/coderay/scanners/sass.rb:16 + def scan_tokens(encoder, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/sass.rb:12 + def setup; end +end + +# = Scanner +# +# The base class for all Scanners. +# +# It is a subclass of Ruby's great +StringScanner+, which +# makes it easy to access the scanning methods inside. +# +# It is also +Enumerable+, so you can use it like an Array of +# Tokens: +# +# require 'coderay' +# +# c_scanner = CodeRay::Scanners[:c].new "if (*p == '{') nest++;" +# +# for text, kind in c_scanner +# puts text if kind == :operator +# end +# +# # prints: (*==)++; +# +# OK, this is a very simple example :) +# You can also use +map+, +any?+, +find+ and even +sort_by+, +# if you want. +# +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:29 +class CodeRay::Scanners::Scanner < ::StringScanner + include ::Enumerable + extend ::CodeRay::Plugin + + # Create a new Scanner. + # + # * +code+ is the input String and is handled by the superclass + # StringScanner. + # * +options+ is a Hash with Symbols as keys. + # It is merged with the default options of the class (you can + # overwrite default options here.) + # + # Else, a Tokens object is used. + # + # @return [Scanner] a new instance of Scanner + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:125 + def initialize(code = T.unsafe(nil), options = T.unsafe(nil)); end + + # The string in binary encoding. + # + # To be used with #pos, which is the index of the byte the scanner + # will scan next. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:218 + def binary_string; end + + # The current column position of the scanner, starting with 1. + # See also: #line. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:209 + def column(pos = T.unsafe(nil)); end + + # Traverse the tokens. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:192 + def each(&block); end + + # the default file extension for this scanner + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:160 + def file_extension; end + + # the Plugin ID for this scanner + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:155 + def lang; end + + # The current line position of the scanner, starting with 1. + # See also: #column. + # + # Beware, this is implemented inefficiently. It should be used + # for debugging only. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:202 + def line(pos = T.unsafe(nil)); end + + # Sets back the scanner. Subclasses should redefine the reset_instance + # method instead of this one. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:142 + def reset; end + + # Returns the value of attribute state. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:44 + def state; end + + # Sets the attribute state + # + # @param value the value to set the attribute state to. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:44 + def state=(_arg0); end + + # Set a new string to be scanned. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:148 + def string=(code); end + + # Scan the code and returns all tokens in a Tokens object. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:165 + def tokenize(source = T.unsafe(nil), options = T.unsafe(nil)); end + + # Cache the result of tokenize. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:187 + def tokens; end + + protected + + # Scanner error with additional status information + # + # @raise [ScanError] + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:314 + def raise_inspect(message, tokens, state = T.unsafe(nil), ambit = T.unsafe(nil), backtrace = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:289 + def raise_inspect_arguments(message, tokens, state, ambit); end + + # Resets the scanner. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:265 + def reset_instance; end + + # Shorthand for scan_until(/\z/). + # This method also avoids a JRuby 1.9 mode bug. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:328 + def scan_rest; end + + # This is the central method, and commonly the only one a + # subclass implements. + # + # Subclasses must implement this method; it must return +tokens+ + # and must only use Tokens#<< for storing scanned tokens! + # + # @raise [NotImplementedError] + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:260 + def scan_tokens(tokens, options); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:305 + def scanner_state_info(state); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:239 + def set_string_from_source(source); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:250 + def set_tokens_from_options(options); end + + # Can be implemented by subclasses to do some initialization + # that has to be done once per instance. + # + # Use reset for initialization that has to be done once per + # scan. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:236 + def setup; end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:322 + def tokens_last(tokens, n); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:318 + def tokens_size(tokens); end + + class << self + # The encoding used internally by this scanner. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:71 + def encoding(name = T.unsafe(nil)); end + + # The typical filename suffix for this scanner's language. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:66 + def file_extension(extension = T.unsafe(nil)); end + + # The lang of this Scanner class, which is equal to its Plugin ID. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:76 + def lang; end + + # Normalizes the given code into a string with UNIX newlines, in the + # scanner's internal encoding, with invalid and undefined charachters + # replaced by placeholders. Always returns a new object. + # + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:51 + def normalize(code); end + + protected + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:82 + def encode_with_encoding(code, target_encoding); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:100 + def guess_encoding(s); end + + # source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:96 + def to_unix(code); end + end +end + +# The default options for all scanner classes. +# +# Define @default_options for subclasses. +# +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:40 +CodeRay::Scanners::Scanner::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:42 +CodeRay::Scanners::Scanner::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:41 +CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners + +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:299 +CodeRay::Scanners::Scanner::SCANNER_STATE_INFO = T.let(T.unsafe(nil), String) + +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:271 +CodeRay::Scanners::Scanner::SCAN_ERROR_MESSAGE = T.let(T.unsafe(nil), String) + +# Raised if a Scanner fails while scanning +# +# source://coderay-1.1.3/lib/coderay/scanners/scanner.rb:35 +class CodeRay::Scanners::Scanner::ScanError < ::StandardError; end + +# source://coderay-1.1.3/lib/coderay/scanners/taskpaper.rb:4 +class CodeRay::Scanners::Taskpaper < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/taskpaper.rb:11 + def scan_tokens(encoder, options); end +end + +# Scanner for plain text. +# +# Yields just one token of the kind :plain. +# +# Alias: +plaintext+, +plain+ +# +# source://coderay-1.1.3/lib/coderay/scanners/text.rb:9 +class CodeRay::Scanners::Text < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/text.rb:18 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/text.rb:14 +CodeRay::Scanners::Text::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array) + +# Scanner for XML. +# +# Currently this is the same scanner as Scanners::HTML. +# +# source://coderay-1.1.3/lib/coderay/scanners/xml.rb:9 +class CodeRay::Scanners::XML < ::CodeRay::Scanners::HTML; end + +# Scanner for YAML. +# +# Based on the YAML scanner from Syntax by Jamis Buck. +# +# source://coderay-1.1.3/lib/coderay/scanners/yaml.rb:7 +class CodeRay::Scanners::YAML < ::CodeRay::Scanners::Scanner + protected + + # source://coderay-1.1.3/lib/coderay/scanners/yaml.rb:16 + def scan_tokens(encoder, options); end +end + +# source://coderay-1.1.3/lib/coderay/scanners/yaml.rb:12 +CodeRay::Scanners::YAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Symbol) + +# This module holds the Style class and its subclasses. +# +# See Plugin. +# +# source://coderay-1.1.3/lib/coderay/styles.rb:6 +module CodeRay::Styles + extend ::CodeRay::PluginHost +end + +# A colorful theme using CSS 3 colors (with alpha channel). +# +# source://coderay-1.1.3/lib/coderay/styles/alpha.rb:5 +class CodeRay::Styles::Alpha < ::CodeRay::Styles::Style; end + +# source://coderay-1.1.3/lib/coderay/styles/alpha.rb:14 +CodeRay::Styles::Alpha::CSS_MAIN_STYLES = T.let(T.unsafe(nil), String) + +# source://coderay-1.1.3/lib/coderay/styles/alpha.rb:53 +CodeRay::Styles::Alpha::TOKEN_COLORS = T.let(T.unsafe(nil), String) + +# Base class for styles. +# +# Styles are used by Encoders::HTML to colorize tokens. +# +# source://coderay-1.1.3/lib/coderay/styles/style.rb:8 +class CodeRay::Styles::Style + extend ::CodeRay::Plugin +end + +# source://coderay-1.1.3/lib/coderay/styles/style.rb:12 +CodeRay::Styles::Style::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://coderay-1.1.3/lib/coderay/helpers/plugin.rb:41 +CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles + +# A Hash of all known token kinds and their associated CSS classes. +# +# source://coderay-1.1.3/lib/coderay/token_kinds.rb:4 +CodeRay::TokenKinds = T.let(T.unsafe(nil), Hash) + +# The Tokens class represents a list of tokens returned from +# a Scanner. It's actually just an Array with a few helper methods. +# +# A token itself is not a special object, just two elements in an Array: +# * the _token_ _text_ (the original source of the token in a String) or +# a _token_ _action_ (begin_group, end_group, begin_line, end_line) +# * the _token_ _kind_ (a Symbol representing the type of the token) +# +# It looks like this: +# +# ..., '# It looks like this', :comment, ... +# ..., '3.1415926', :float, ... +# ..., '$^', :error, ... +# +# Some scanners also yield sub-tokens, represented by special +# token actions, for example :begin_group and :end_group. +# +# The Ruby scanner, for example, splits "a string" into: +# +# [ +# :begin_group, :string, +# '"', :delimiter, +# 'a string', :content, +# '"', :delimiter, +# :end_group, :string +# ] +# +# Tokens can be used to save the output of a Scanners in a simple +# Ruby object that can be send to an Encoder later: +# +# tokens = CodeRay.scan('price = 2.59', :ruby).tokens +# tokens.encode(:html) +# tokens.html +# CodeRay.encoder(:html).encode_tokens(tokens) +# +# Tokens gives you the power to handle pre-scanned code very easily: +# You can serialize it to a JSON string and store it in a database, pass it +# around to encode it more than once, send it to other algorithms... +# +# source://coderay-1.1.3/lib/coderay/tokens.rb:43 +class CodeRay::Tokens < ::Array + # source://coderay-1.1.3/lib/coderay/tokens.rb:156 + def begin_group(kind); end + + # source://coderay-1.1.3/lib/coderay/tokens.rb:158 + def begin_line(kind); end + + # Return the actual number of tokens. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:151 + def count; end + + # Encode the tokens using encoder. + # + # encoder can be + # * a plugin name like :html oder 'statistic' + # * an Encoder object + # + # options are passed to the encoder. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:56 + def encode(encoder, options = T.unsafe(nil)); end + + # source://coderay-1.1.3/lib/coderay/tokens.rb:157 + def end_group(kind); end + + # source://coderay-1.1.3/lib/coderay/tokens.rb:159 + def end_line(kind); end + + # Redirects unknown methods to encoder calls. + # + # For example, if you call +tokens.html+, the HTML encoder + # is used to highlight the tokens. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:70 + def method_missing(meth, options = T.unsafe(nil)); end + + # The Scanner instance that created the tokens. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:47 + def scanner; end + + # The Scanner instance that created the tokens. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:47 + def scanner=(_arg0); end + + # Split the tokens into parts of the given +sizes+. + # + # The result will be an Array of Tokens objects. The parts have + # the text size specified by the parameter. In addition, each + # part closes all opened tokens. This is useful to insert tokens + # betweem them. + # + # This method is used by @Scanner#tokenize@ when called with an Array + # of source strings. The Diff encoder uses it for inline highlighting. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:85 + def split_into_parts(*sizes); end + + def text_token(*_arg0); end + + # Turn tokens into a string by concatenating them. + # + # source://coderay-1.1.3/lib/coderay/tokens.rb:62 + def to_s; end + + def tokens(*_arg0); end +end + +# The result of a scan operation is a TokensProxy, but should act like Tokens. +# +# This proxy makes it possible to use the classic CodeRay.scan.encode API +# while still providing the benefits of direct streaming. +# +# source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:7 +class CodeRay::TokensProxy + # Create a new TokensProxy with the arguments of CodeRay.scan. + # + # @return [TokensProxy] a new instance of TokensProxy + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:12 + def initialize(input, lang, options = T.unsafe(nil), block = T.unsafe(nil)); end + + # Returns the value of attribute block. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def block=(_arg0); end + + # Overwrite Struct#each. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:48 + def each(*args, &blk); end + + # Call CodeRay.encode if +encoder+ is a Symbol; + # otherwise, convert the receiver to tokens and call encoder.encode_tokens. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:21 + def encode(encoder, options = T.unsafe(nil)); end + + # Returns the value of attribute input. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def input; end + + # Sets the attribute input + # + # @param value the value to set the attribute input to. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def input=(_arg0); end + + # Returns the value of attribute lang. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def lang; end + + # Sets the attribute lang + # + # @param value the value to set the attribute lang to. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def lang=(_arg0); end + + # Tries to call encode; + # delegates to tokens otherwise. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:31 + def method_missing(method, *args, &blk); end + + # Returns the value of attribute options. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def options; end + + # Sets the attribute options + # + # @param value the value to set the attribute options to. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:9 + def options=(_arg0); end + + # A (cached) scanner instance to use for the scan task. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:43 + def scanner; end + + # The (cached) result of the tokenized input; a Tokens instance. + # + # source://coderay-1.1.3/lib/coderay/tokens_proxy.rb:38 + def tokens; end +end + +# source://coderay-1.1.3/lib/coderay/version.rb:2 +CodeRay::VERSION = T.let(T.unsafe(nil), String) + +# = WordList +# +# A Hash subclass designed for mapping word lists to token types. +# +# A WordList is a Hash with some additional features. +# It is intended to be used for keyword recognition. +# +# WordList is optimized to be used in Scanners, +# typically to decide whether a given ident is a special token. +# +# For case insensitive words use WordList::CaseIgnoring. +# +# Example: +# +# # define word arrays +# RESERVED_WORDS = %w[ +# asm break case continue default do else +# ] +# +# PREDEFINED_TYPES = %w[ +# int long short char void +# ] +# +# # make a WordList +# IDENT_KIND = WordList.new(:ident). +# add(RESERVED_WORDS, :reserved). +# add(PREDEFINED_TYPES, :predefined_type) +# +# ... +# +# def scan_tokens tokens, options +# ... +# +# elsif scan(/[A-Za-z_][A-Za-z_0-9]*/) +# # use it +# kind = IDENT_KIND[match] +# ... +# +# source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:40 +class CodeRay::WordList < ::Hash + # Create a new WordList with +default+ as default value. + # + # @return [WordList] a new instance of WordList + # + # source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:43 + def initialize(default = T.unsafe(nil)); end + + # Add words to the list and associate them with +value+. + # + # Returns +self+, so you can concat add calls. + # + # source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:50 + def add(words, value = T.unsafe(nil)); end +end + +# A CaseIgnoring WordList is like a WordList, only that +# keys are compared case-insensitively (normalizing keys using +downcase+). +# +# source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:60 +class CodeRay::WordList::CaseIgnoring < ::CodeRay::WordList + # source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:62 + def [](key); end + + # source://coderay-1.1.3/lib/coderay/helpers/word_list.rb:66 + def []=(key, value); end +end diff --git a/sorbet/rbi/gems/diff-lcs@1.5.0.rbi b/sorbet/rbi/gems/diff-lcs@1.5.0.rbi new file mode 100644 index 00000000..ee9f121a --- /dev/null +++ b/sorbet/rbi/gems/diff-lcs@1.5.0.rbi @@ -0,0 +1,1079 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `diff-lcs` gem. +# Please instead update this file by running `bin/tapioca gem diff-lcs`. + +# source://diff-lcs-1.5.0/lib/diff/lcs.rb:3 +module Diff; end + +# source://diff-lcs-1.5.0/lib/diff/lcs.rb:51 +module Diff::LCS + # Returns the difference set between +self+ and +other+. See Diff::LCS#diff. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:75 + def diff(other, callbacks = T.unsafe(nil), &block); end + + # Returns an Array containing the longest common subsequence(s) between + # +self+ and +other+. See Diff::LCS#lcs. + # + # lcs = seq1.lcs(seq2) + # + # A note when using objects: Diff::LCS only works properly when each object + # can be used as a key in a Hash, which typically means that the objects must + # implement Object#eql? in a way that two identical values compare + # identically for key purposes. That is: + # + # O.new('a').eql?(O.new('a')) == true + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:70 + def lcs(other, &block); end + + # Attempts to patch +self+ with the provided +patchset+. A new sequence based + # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts + # to autodiscover the direction of the patch. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:101 + def patch(patchset); end + + # Attempts to patch +self+ with the provided +patchset+. A new sequence based + # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Does no + # patch direction autodiscovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:109 + def patch!(patchset); end + + # Attempts to patch +self+ with the provided +patchset+, using #patch!. If + # the sequence this is used on supports #replace, the value of +self+ will be + # replaced. See Diff::LCS#patch. Does no patch direction autodiscovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:123 + def patch_me(patchset); end + + # Returns the balanced ("side-by-side") difference set between +self+ and + # +other+. See Diff::LCS#sdiff. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:81 + def sdiff(other, callbacks = T.unsafe(nil), &block); end + + # Traverses the discovered longest common subsequences between +self+ and + # +other+ using the alternate, balanced algorithm. See + # Diff::LCS#traverse_balanced. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:94 + def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end + + # Traverses the discovered longest common subsequences between +self+ and + # +other+. See Diff::LCS#traverse_sequences. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:87 + def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end + + # Attempts to patch +self+ with the provided +patchset+. A new sequence based + # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts + # to autodiscover the direction of the patch. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:101 + def unpatch(patchset); end + + # Attempts to unpatch +self+ with the provided +patchset+. A new sequence + # based on +self+ and the +patchset+ will be created. See Diff::LCS#unpatch. + # Does no patch direction autodiscovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:116 + def unpatch!(patchset); end + + # Attempts to unpatch +self+ with the provided +patchset+, using #unpatch!. + # If the sequence this is used on supports #replace, the value of +self+ will + # be replaced. See Diff::LCS#unpatch. Does no patch direction autodiscovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:134 + def unpatch_me(patchset); end + + class << self + # :yields seq1[i] for each matched: + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:144 + def LCS(seq1, seq2, &block); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:52 + def callbacks_for(callbacks); end + + # #diff computes the smallest set of additions and deletions necessary to + # turn the first sequence into the second, and returns a description of these + # changes. + # + # See Diff::LCS::DiffCallbacks for the default behaviour. An alternate + # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a + # Class argument is provided for +callbacks+, #diff will attempt to + # initialise it. If the +callbacks+ object (possibly initialised) responds to + # #finish, it will be called. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:168 + def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end + + # :yields seq1[i] for each matched: + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:144 + def lcs(seq1, seq2, &block); end + + # Applies a +patchset+ to the sequence +src+ according to the +direction+ + # (:patch or :unpatch), producing a new sequence. + # + # If the +direction+ is not specified, Diff::LCS::patch will attempt to + # discover the direction of the +patchset+. + # + # A +patchset+ can be considered to apply forward (:patch) if the + # following expression is true: + # + # patch(s1, diff(s1, s2)) -> s2 + # + # A +patchset+ can be considered to apply backward (:unpatch) if the + # following expression is true: + # + # patch(s2, diff(s1, s2)) -> s1 + # + # If the +patchset+ contains no changes, the +src+ value will be returned as + # either src.dup or +src+. A +patchset+ can be deemed as having no + # changes if the following predicate returns true: + # + # patchset.empty? or + # patchset.flatten(1).all? { |change| change.unchanged? } + # + # === Patchsets + # + # A +patchset+ is always an enumerable sequence of changes, hunks of changes, + # or a mix of the two. A hunk of changes is an enumerable sequence of + # changes: + # + # [ # patchset + # # change + # [ # hunk + # # change + # ] + # ] + # + # The +patch+ method accepts patchsets that are enumerable sequences + # containing either Diff::LCS::Change objects (or a subclass) or the array + # representations of those objects. Prior to application, array + # representations of Diff::LCS::Change objects will be reified. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:624 + def patch(src, patchset, direction = T.unsafe(nil)); end + + # Given a set of patchset, convert the current version to the next version. + # Does no auto-discovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:734 + def patch!(src, patchset); end + + # #sdiff computes all necessary components to show two sequences and their + # minimized differences side by side, just like the Unix utility + # sdiff does: + # + # old < - + # same same + # before | after + # - > new + # + # See Diff::LCS::SDiffCallbacks for the default behaviour. An alternate + # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If a + # Class argument is provided for +callbacks+, #diff will attempt to + # initialise it. If the +callbacks+ object (possibly initialised) responds to + # #finish, it will be called. + # + # Each element of a returned array is a Diff::LCS::ContextChange object, + # which can be implicitly converted to an array. + # + # Diff::LCS.sdiff(a, b).each do |action, (old_pos, old_element), (new_pos, new_element)| + # case action + # when '!' + # # replace + # when '-' + # # delete + # when '+' + # # insert + # end + # end + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:200 + def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end + + # #traverse_balanced is an alternative to #traverse_sequences. It uses a + # different algorithm to iterate through the entries in the computed longest + # common subsequence. Instead of viewing the changes as insertions or + # deletions from one of the sequences, #traverse_balanced will report + # changes between the sequences. + # + # The arguments to #traverse_balanced are the two sequences to traverse and a + # callback object, like this: + # + # traverse_balanced(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) + # + # #sdiff is implemented with #traverse_balanced. + # + # == Callback Methods + # + # Optional callback methods are emphasized. + # + # callbacks#match:: Called when +a+ and +b+ are pointing to + # common elements in +A+ and +B+. + # callbacks#discard_a:: Called when +a+ is pointing to an + # element not in +B+. + # callbacks#discard_b:: Called when +b+ is pointing to an + # element not in +A+. + # callbacks#change:: Called when +a+ and +b+ are pointing to + # the same relative position, but + # A[a] and B[b] are not + # the same; a change has + # occurred. + # + # #traverse_balanced might be a bit slower than #traverse_sequences, + # noticable only while processing huge amounts of data. + # + # == Algorithm + # + # a---+ + # v + # A = a b c e h j l m n p + # B = b c d e f j k l m r s t + # ^ + # b---+ + # + # === Matches + # + # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+ + # and +B+, the arrows will initially point to the first elements of their + # respective sequences. #traverse_sequences will advance the arrows through + # the sequences one element at a time, calling a method on the user-specified + # callback object before each advance. It will advance the arrows in such a + # way that if there are elements A[i] and B[j] which are + # both equal and part of the longest common subsequence, there will be some + # moment during the execution of #traverse_sequences when arrow +a+ is + # pointing to A[i] and arrow +b+ is pointing to B[j]. When + # this happens, #traverse_sequences will call callbacks#match and + # then it will advance both arrows. + # + # === Discards + # + # Otherwise, one of the arrows is pointing to an element of its sequence that + # is not part of the longest common subsequence. #traverse_sequences will + # advance that arrow and will call callbacks#discard_a or + # callbacks#discard_b, depending on which arrow it advanced. + # + # === Changes + # + # If both +a+ and +b+ point to elements that are not part of the longest + # common subsequence, then #traverse_sequences will try to call + # callbacks#change and advance both arrows. If + # callbacks#change is not implemented, then + # callbacks#discard_a and callbacks#discard_b will be + # called in turn. + # + # The methods for callbacks#match, callbacks#discard_a, + # callbacks#discard_b, and callbacks#change are invoked + # with an event comprising the action ("=", "+", "-", or "!", respectively), + # the indicies +i+ and +j+, and the elements A[i] and B[j]. + # Return values are discarded by #traverse_balanced. + # + # === Context + # + # Note that +i+ and +j+ may not be the same index position, even if +a+ and + # +b+ are considered to be pointing to matching or changed elements. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:475 + def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end + + # #traverse_sequences is the most general facility provided by this module; + # #diff and #lcs are implemented as calls to it. + # + # The arguments to #traverse_sequences are the two sequences to traverse, and + # a callback object, like this: + # + # traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) + # + # == Callback Methods + # + # Optional callback methods are emphasized. + # + # callbacks#match:: Called when +a+ and +b+ are pointing to + # common elements in +A+ and +B+. + # callbacks#discard_a:: Called when +a+ is pointing to an + # element not in +B+. + # callbacks#discard_b:: Called when +b+ is pointing to an + # element not in +A+. + # callbacks#finished_a:: Called when +a+ has reached the end of + # sequence +A+. + # callbacks#finished_b:: Called when +b+ has reached the end of + # sequence +B+. + # + # == Algorithm + # + # a---+ + # v + # A = a b c e h j l m n p + # B = b c d e f j k l m r s t + # ^ + # b---+ + # + # If there are two arrows (+a+ and +b+) pointing to elements of sequences +A+ + # and +B+, the arrows will initially point to the first elements of their + # respective sequences. #traverse_sequences will advance the arrows through + # the sequences one element at a time, calling a method on the user-specified + # callback object before each advance. It will advance the arrows in such a + # way that if there are elements A[i] and B[j] which are + # both equal and part of the longest common subsequence, there will be some + # moment during the execution of #traverse_sequences when arrow +a+ is + # pointing to A[i] and arrow +b+ is pointing to B[j]. When + # this happens, #traverse_sequences will call callbacks#match and + # then it will advance both arrows. + # + # Otherwise, one of the arrows is pointing to an element of its sequence that + # is not part of the longest common subsequence. #traverse_sequences will + # advance that arrow and will call callbacks#discard_a or + # callbacks#discard_b, depending on which arrow it advanced. If both + # arrows point to elements that are not part of the longest common + # subsequence, then #traverse_sequences will advance arrow +a+ and call the + # appropriate callback, then it will advance arrow +b+ and call the appropriate + # callback. + # + # The methods for callbacks#match, callbacks#discard_a, and + # callbacks#discard_b are invoked with an event comprising the + # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the + # elements A[i] and B[j]. Return values are discarded by + # #traverse_sequences. + # + # === End of Sequences + # + # If arrow +a+ reaches the end of its sequence before arrow +b+ does, + # #traverse_sequence will try to call callbacks#finished_a with the + # last index and element of +A+ (A[-1]) and the current index and + # element of +B+ (B[j]). If callbacks#finished_a does not + # exist, then callbacks#discard_b will be called on each element of + # +B+ until the end of the sequence is reached (the call will be done with + # A[-1] and B[j] for each element). + # + # If +b+ reaches the end of +B+ before +a+ reaches the end of +A+, + # callbacks#finished_b will be called with the current index and + # element of +A+ (A[i]) and the last index and element of +B+ + # (A[-1]). Again, if callbacks#finished_b does not exist on + # the callback object, then callbacks#discard_a will be called on + # each element of +A+ until the end of the sequence is reached (A[i] + # and B[-1]). + # + # There is a chance that one additional callbacks#discard_a or + # callbacks#discard_b will be called after the end of the sequence + # is reached, if +a+ has not yet reached the end of +A+ or +b+ has not yet + # reached the end of +B+. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:285 + def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end + + # Given a set of patchset, convert the current version to the prior version. + # Does no auto-discovery. + # + # source://diff-lcs-1.5.0/lib/diff/lcs.rb:728 + def unpatch!(src, patchset); end + + private + + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:4 + def diff_traversal(method, seq1, seq2, callbacks, &block); end + end +end + +# An alias for DefaultCallbacks that is used in +# Diff::LCS#traverse_balanced. +# +# Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks) +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:50 +Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks + +# A block is an operation removing, adding, or changing a group of items. +# Basically, this is just a list of changes, where each change adds or +# deletes a single item. Used by bin/ldiff. +# +# source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:6 +class Diff::LCS::Block + # @return [Block] a new instance of Block + # + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:9 + def initialize(chunk); end + + # Returns the value of attribute changes. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7 + def changes; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:21 + def diff_size; end + + # Returns the value of attribute insert. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7 + def insert; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:25 + def op; end + + # Returns the value of attribute remove. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7 + def remove; end +end + +# Represents a simplistic (non-contextual) change. Represents the removal or +# addition of an element from either the old or the new sequenced +# enumerable. +# +# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:6 +class Diff::LCS::Change + include ::Comparable + + # @return [Change] a new instance of Change + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:27 + def initialize(*args); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:65 + def <=>(other); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:58 + def ==(other); end + + # Returns the action this Change represents. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:20 + def action; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:72 + def adding?; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:84 + def changed?; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:76 + def deleting?; end + + # Returns the sequence element of the Change. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:25 + def element; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:88 + def finished_a?; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:92 + def finished_b?; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:34 + def inspect(*_args); end + + # Returns the position of the Change. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:23 + def position; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:38 + def to_a; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:38 + def to_ary; end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:80 + def unchanged?; end + + class << self + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:44 + def from_a(arr); end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:15 + def valid_action?(action); end + end +end + +# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:7 +Diff::LCS::Change::IntClass = Integer + +# The only actions valid for changes are '+' (add), '-' (delete), '=' +# (no change), '!' (changed), '<' (tail changes from first sequence), or +# '>' (tail changes from second sequence). The last two ('<>') are only +# found with Diff::LCS::diff and Diff::LCS::sdiff. +# +# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:13 +Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array) + +# Represents a contextual change. Contains the position and values of the +# elements in the old and the new sequenced enumerables as well as the action +# taken. +# +# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:101 +class Diff::LCS::ContextChange < ::Diff::LCS::Change + # @return [ContextChange] a new instance of ContextChange + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:114 + def initialize(*args); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:166 + def <=>(other); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:157 + def ==(other); end + + # Returns the new element being changed. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:112 + def new_element; end + + # Returns the new position being changed. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:108 + def new_position; end + + # Returns the old element being changed. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:110 + def old_element; end + + # Returns the old position being changed. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:106 + def old_position; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:122 + def to_a; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:122 + def to_ary; end + + class << self + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:132 + def from_a(arr); end + + # Simplifies a context change for use in some diff callbacks. '<' actions + # are converted to '-' and '>' actions are converted to '+'. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:138 + def simplify(event); end + end +end + +# This will produce a compound array of contextual diff change objects. Each +# element in the #diffs array is a "hunk" array, where each element in each +# "hunk" array is a single change. Each change is a Diff::LCS::ContextChange +# that contains both the old index and new index values for the change. The +# "hunk" provides the full context for the changes. Both old and new objects +# will be presented for changed objects. +nil+ will be substituted for a +# discarded object. +# +# seq1 = %w(a b c e h j l m n p) +# seq2 = %w(b c d e f j k l m r s t) +# +# diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks) +# # This example shows a simplified array format. +# # [ [ [ '-', [ 0, 'a' ], [ 0, nil ] ] ], # 1 +# # [ [ '+', [ 3, nil ], [ 2, 'd' ] ] ], # 2 +# # [ [ '-', [ 4, 'h' ], [ 4, nil ] ], # 3 +# # [ '+', [ 5, nil ], [ 4, 'f' ] ] ], +# # [ [ '+', [ 6, nil ], [ 6, 'k' ] ] ], # 4 +# # [ [ '-', [ 8, 'n' ], [ 9, nil ] ], # 5 +# # [ '+', [ 9, nil ], [ 9, 'r' ] ], +# # [ '-', [ 9, 'p' ], [ 10, nil ] ], +# # [ '+', [ 10, nil ], [ 10, 's' ] ], +# # [ '+', [ 10, nil ], [ 11, 't' ] ] ] ] +# +# The five hunks shown are comprised of individual changes; if there is a +# related set of changes, they are still shown individually. +# +# This callback can also be used with Diff::LCS#sdiff, which will produce +# results like: +# +# diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks) +# # This example shows a simplified array format. +# # [ [ [ "-", [ 0, "a" ], [ 0, nil ] ] ], # 1 +# # [ [ "+", [ 3, nil ], [ 2, "d" ] ] ], # 2 +# # [ [ "!", [ 4, "h" ], [ 4, "f" ] ] ], # 3 +# # [ [ "+", [ 6, nil ], [ 6, "k" ] ] ], # 4 +# # [ [ "!", [ 8, "n" ], [ 9, "r" ] ], # 5 +# # [ "!", [ 9, "p" ], [ 10, "s" ] ], +# # [ "+", [ 10, nil ], [ 11, "t" ] ] ] ] +# +# The five hunks are still present, but are significantly shorter in total +# presentation, because changed items are shown as changes ("!") instead of +# potentially "mismatched" pairs of additions and deletions. +# +# The result of this operation is similar to that of +# Diff::LCS::SDiffCallbacks. They may be compared as: +# +# s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } +# c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1) +# +# s == c # -> true +# +# === Use +# +# This callback object must be initialised and can be used by the +# Diff::LCS#diff or Diff::LCS#sdiff methods. +# +# cbo = Diff::LCS::ContextDiffCallbacks.new +# Diff::LCS.LCS(seq1, seq2, cbo) +# cbo.finish +# +# Note that the call to #finish is absolutely necessary, or the last set of +# changes will not be visible. Alternatively, can be used as: +# +# cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } +# +# The necessary #finish call will be made. +# +# === Simplified Array Format +# +# The simplified array format used in the example above can be obtained +# with: +# +# require 'pp' +# pp diffs.map { |e| e.map { |f| f.to_a } } +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:223 +class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:232 + def change(event); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:224 + def discard_a(event); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:228 + def discard_b(event); end +end + +# This callback object implements the default set of callback events, +# which only returns the event itself. Note that #finished_a and +# #finished_b are not implemented -- I haven't yet figured out where they +# would be useful. +# +# Note that this is intended to be called as is, e.g., +# +# Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks) +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:14 +class Diff::LCS::DefaultCallbacks + class << self + # Called when both the old and new values have changed. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:32 + def change(event); end + + # Called when the old value is discarded in favour of the new value. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:22 + def discard_a(event); end + + # Called when the new value is discarded in favour of the old value. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:27 + def discard_b(event); end + + # Called when two items match. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:17 + def match(event); end + end +end + +# This will produce a compound array of simple diff change objects. Each +# element in the #diffs array is a +hunk+ or +hunk+ array, where each +# element in each +hunk+ array is a single Change object representing the +# addition or removal of a single element from one of the two tested +# sequences. The +hunk+ provides the full context for the changes. +# +# diffs = Diff::LCS.diff(seq1, seq2) +# # This example shows a simplified array format. +# # [ [ [ '-', 0, 'a' ] ], # 1 +# # [ [ '+', 2, 'd' ] ], # 2 +# # [ [ '-', 4, 'h' ], # 3 +# # [ '+', 4, 'f' ] ], +# # [ [ '+', 6, 'k' ] ], # 4 +# # [ [ '-', 8, 'n' ], # 5 +# # [ '-', 9, 'p' ], +# # [ '+', 9, 'r' ], +# # [ '+', 10, 's' ], +# # [ '+', 11, 't' ] ] ] +# +# There are five hunks here. The first hunk says that the +a+ at position 0 +# of the first sequence should be deleted ('-'). The second hunk +# says that the +d+ at position 2 of the second sequence should be inserted +# ('+'). The third hunk says that the +h+ at position 4 of the +# first sequence should be removed and replaced with the +f+ from position 4 +# of the second sequence. The other two hunks are described similarly. +# +# === Use +# +# This callback object must be initialised and is used by the Diff::LCS#diff +# method. +# +# cbo = Diff::LCS::DiffCallbacks.new +# Diff::LCS.LCS(seq1, seq2, cbo) +# cbo.finish +# +# Note that the call to #finish is absolutely necessary, or the last set of +# changes will not be visible. Alternatively, can be used as: +# +# cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } +# +# The necessary #finish call will be made. +# +# === Simplified Array Format +# +# The simplified array format used in the example above can be obtained +# with: +# +# require 'pp' +# pp diffs.map { |e| e.map { |f| f.to_a } } +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:106 +class Diff::LCS::DiffCallbacks + # :yields self: + # + # @return [DiffCallbacks] a new instance of DiffCallbacks + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:110 + def initialize; end + + # Returns the difference set collected during the diff process. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:108 + def diffs; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:133 + def discard_a(event); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:137 + def discard_b(event); end + + # Finalizes the diff process. If an unprocessed hunk still exists, then it + # is appended to the diff list. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:125 + def finish; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:129 + def match(_event); end + + private + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:141 + def finish_hunk; end +end + +# A Hunk is a group of Blocks which overlap because of the context surrounding +# each block. (So if we're not using context, every hunk will contain one +# block.) Used in the diff program (bin/ldiff). +# +# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:8 +class Diff::LCS::Hunk + # Create a hunk using references to both the old and new data, as well as the + # piece of data. + # + # @return [Hunk] a new instance of Hunk + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:16 + def initialize(data_old, data_new, piece, flag_context, file_length_difference); end + + # Returns the value of attribute blocks. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:63 + def blocks; end + + # Returns a diff string based on a format. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:116 + def diff(format, last = T.unsafe(nil)); end + + # Returns the value of attribute end_new. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:65 + def end_new; end + + # Returns the value of attribute end_old. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:65 + def end_old; end + + # Returns the value of attribute file_length_difference. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:66 + def file_length_difference; end + + # Change the "start" and "end" fields to note that context should be added + # to this hunk. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:70 + def flag_context; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:72 + def flag_context=(context); end + + # Merges this hunk and the provided hunk together if they overlap. Returns + # a truthy value so that if there is no overlap, you can know the merge + # was skipped. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:98 + def merge(hunk); end + + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:326 + def missing_last_newline?(data); end + + # Determines whether there is an overlap between this hunk and the + # provided hunk. This will be true if the difference between the two hunks + # start or end positions is within one position of each other. + # + # @return [Boolean] + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:110 + def overlaps?(hunk); end + + # Returns the value of attribute start_new. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:64 + def start_new; end + + # Returns the value of attribute start_old. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:64 + def start_old; end + + # Merges this hunk and the provided hunk together if they overlap. Returns + # a truthy value so that if there is no overlap, you can know the merge + # was skipped. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:98 + def unshift(hunk); end + + private + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:213 + def context_diff(last = T.unsafe(nil)); end + + # Generate a range of item numbers to print. Only print 1 number if the + # range has only one item in it. Otherwise, it's 'start,end' + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:293 + def context_range(mode, op, last = T.unsafe(nil)); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:271 + def ed_diff(format, _last = T.unsafe(nil)); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:339 + def encode(literal, target_encoding = T.unsafe(nil)); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:343 + def encode_as(string, *args); end + + # Note that an old diff can't have any context. Therefore, we know that + # there's only one block in the hunk. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:135 + def old_diff(_last = T.unsafe(nil)); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:160 + def unified_diff(last = T.unsafe(nil)); end + + # Generate a range of item numbers to print for unified diff. Print number + # where block starts, followed by number of lines in the block + # (don't print number of lines if it's 1) + # + # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:311 + def unified_range(mode, last); end +end + +# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:10 +Diff::LCS::Hunk::ED_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash) + +# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:9 +Diff::LCS::Hunk::OLD_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash) + +# source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:29 +module Diff::LCS::Internals + class << self + # This method will analyze the provided patchset to provide a single-pass + # normalization (conversion of the array form of Diff::LCS::Change objects to + # the object form of same) and detection of whether the patchset represents + # changes to be made. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:102 + def analyze_patchset(patchset, depth = T.unsafe(nil)); end + + # Examine the patchset and the source to see in which direction the + # patch should be applied. + # + # WARNING: By default, this examines the whole patch, so this could take + # some time. This also works better with Diff::LCS::ContextChange or + # Diff::LCS::Change as its source, as an array will cause the creation + # of one of the above. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:147 + def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end + + # Compute the longest common subsequence between the sequenced + # Enumerables +a+ and +b+. The result is an array whose contents is such + # that + # + # result = Diff::LCS::Internals.lcs(a, b) + # result.each_with_index do |e, i| + # assert_equal(a[i], b[e]) unless e.nil? + # end + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:41 + def lcs(a, b); end + + private + + # If +vector+ maps the matching elements of another collection onto this + # Enumerable, compute the inverse of +vector+ that maps this Enumerable + # onto the collection. (Currently unused.) + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:286 + def inverse_vector(a, vector); end + + # Returns a hash mapping each element of an Enumerable to the set of + # positions it occupies in the Enumerable, optionally restricted to the + # elements specified in the range of indexes specified by +interval+. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:298 + def position_hash(enum, interval); end + + # Find the place at which +value+ would normally be inserted into the + # Enumerable. If that place is already occupied by +value+, do nothing + # and return +nil+. If the place does not exist (i.e., it is off the end + # of the Enumerable), add it to the end. Otherwise, replace the element + # at that point with +value+. It is assumed that the Enumerable's values + # are numeric. + # + # This operation preserves the sort order. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:252 + def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end + end +end + +# This will produce a simple array of diff change objects. Each element in +# the #diffs array is a single ContextChange. In the set of #diffs provided +# by SDiffCallbacks, both old and new objects will be presented for both +# changed and unchanged objects. +nil+ will be substituted +# for a discarded object. +# +# The diffset produced by this callback, when provided to Diff::LCS#sdiff, +# will compute and display the necessary components to show two sequences +# and their minimized differences side by side, just like the Unix utility +# +sdiff+. +# +# same same +# before | after +# old < - +# - > new +# +# seq1 = %w(a b c e h j l m n p) +# seq2 = %w(b c d e f j k l m r s t) +# +# diffs = Diff::LCS.sdiff(seq1, seq2) +# # This example shows a simplified array format. +# # [ [ "-", [ 0, "a"], [ 0, nil ] ], +# # [ "=", [ 1, "b"], [ 0, "b" ] ], +# # [ "=", [ 2, "c"], [ 1, "c" ] ], +# # [ "+", [ 3, nil], [ 2, "d" ] ], +# # [ "=", [ 3, "e"], [ 3, "e" ] ], +# # [ "!", [ 4, "h"], [ 4, "f" ] ], +# # [ "=", [ 5, "j"], [ 5, "j" ] ], +# # [ "+", [ 6, nil], [ 6, "k" ] ], +# # [ "=", [ 6, "l"], [ 7, "l" ] ], +# # [ "=", [ 7, "m"], [ 8, "m" ] ], +# # [ "!", [ 8, "n"], [ 9, "r" ] ], +# # [ "!", [ 9, "p"], [ 10, "s" ] ], +# # [ "+", [ 10, nil], [ 11, "t" ] ] ] +# +# The result of this operation is similar to that of +# Diff::LCS::ContextDiffCallbacks. They may be compared as: +# +# s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } +# c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1) +# +# s == c # -> true +# +# === Use +# +# This callback object must be initialised and is used by the Diff::LCS#sdiff +# method. +# +# cbo = Diff::LCS::SDiffCallbacks.new +# Diff::LCS.LCS(seq1, seq2, cbo) +# +# As with the other initialisable callback objects, +# Diff::LCS::SDiffCallbacks can be initialised with a block. As there is no +# "fininishing" to be done, this has no effect on the state of the object. +# +# cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } +# +# === Simplified Array Format +# +# The simplified array format used in the example above can be obtained +# with: +# +# require 'pp' +# pp diffs.map { |e| e.to_a } +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:301 +class Diff::LCS::SDiffCallbacks + # :yields self: + # + # @return [SDiffCallbacks] a new instance of SDiffCallbacks + # @yield [_self] + # @yieldparam _self [Diff::LCS::SDiffCallbacks] the object that the method was called on + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:305 + def initialize; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:322 + def change(event); end + + # Returns the difference set collected during the diff process. + # + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:303 + def diffs; end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:314 + def discard_a(event); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:318 + def discard_b(event); end + + # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:310 + def match(event); end +end + +# An alias for DefaultCallbacks that is used in +# Diff::LCS#traverse_sequences. +# +# Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks) +# +# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:44 +Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks + +# source://diff-lcs-1.5.0/lib/diff/lcs.rb:52 +Diff::LCS::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/docile.rbi b/sorbet/rbi/gems/docile.rbi deleted file mode 100644 index 6314c6c7..00000000 --- a/sorbet/rbi/gems/docile.rbi +++ /dev/null @@ -1,36 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/docile/all/docile.rbi -# -# docile-1.4.0 - -module Docile - def dsl_eval(dsl, *args, &block); end - def dsl_eval_immutable(dsl, *args, &block); end - def dsl_eval_with_block_return(dsl, *args, &block); end - def self.dsl_eval(dsl, *args, &block); end - def self.dsl_eval_immutable(dsl, *args, &block); end - def self.dsl_eval_with_block_return(dsl, *args, &block); end - extend Docile::Execution -end -module Docile::Execution - def exec_in_proxy_context(dsl, proxy_type, *args, &block); end - def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end -end -class Docile::FallbackContextProxy - def initialize(receiver, fallback); end - def instance_variables; end - def method_missing(method, *args, &block); end -end -class Docile::ChainingFallbackContextProxy < Docile::FallbackContextProxy - def method_missing(method, *args, &block); end -end -module Docile::BacktraceFilter - def backtrace; end - def backtrace_locations; end -end diff --git a/sorbet/rbi/gems/docile@1.4.0.rbi b/sorbet/rbi/gems/docile@1.4.0.rbi new file mode 100644 index 00000000..6c12f6f1 --- /dev/null +++ b/sorbet/rbi/gems/docile@1.4.0.rbi @@ -0,0 +1,376 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `docile` gem. +# Please instead update this file by running `bin/tapioca gem docile`. + +# Docile keeps your Ruby DSLs tame and well-behaved. +# +# source://docile-1.4.0/lib/docile/version.rb:3 +module Docile + extend ::Docile::Execution + + private + + # Execute a block in the context of an object whose methods represent the + # commands in a DSL. + # + # Use this method to execute an *imperative* DSL, which means that: + # + # 1. Each command mutates the state of the DSL context object + # 2. The return value of each command is ignored + # 3. The final return value is the original context object + # + # @example Use a String as a DSL + # Docile.dsl_eval("Hello, world!") do + # reverse! + # upcase! + # end + # #=> "!DLROW ,OLLEH" + # @example Use an Array as a DSL + # Docile.dsl_eval([]) do + # push 1 + # push 2 + # pop + # push 3 + # end + # #=> [1, 3] + # @note Use with an *imperative* DSL (commands modify the context object) + # @param dsl [Object] context object whose methods make up the DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object + # @return [Object] the `dsl` context object after executing the block + # + # source://docile-1.4.0/lib/docile.rb:45 + def dsl_eval(dsl, *args, &block); end + + # Execute a block in the context of an immutable object whose methods, + # and the methods of their return values, represent the commands in a DSL. + # + # Use this method to execute a *functional* DSL, which means that: + # + # 1. The original DSL context object is never mutated + # 2. Each command returns the next DSL context object + # 3. The final return value is the value returned by the last command + # + # @example Use a frozen String as a DSL + # Docile.dsl_eval_immutable("I'm immutable!".freeze) do + # reverse + # upcase + # end + # #=> "!ELBATUMMI M'I" + # @example Use a Float as a DSL + # Docile.dsl_eval_immutable(84.5) do + # fdiv(2) + # floor + # end + # #=> 42 + # @note Use with a *functional* DSL (commands return successor + # context objects) + # @param dsl [Object] immutable context object whose methods make up the + # initial DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object and successor return values + # @return [Object] the return value of the final command in the block + # + # source://docile-1.4.0/lib/docile.rb:128 + def dsl_eval_immutable(dsl, *args, &block); end + + # Execute a block in the context of an object whose methods represent the + # commands in a DSL, and return *the block's return value*. + # + # Use this method to execute an *imperative* DSL, which means that: + # + # 1. Each command mutates the state of the DSL context object + # 2. The return value of each command is ignored + # 3. The final return value is the original context object + # + # @example Use a String as a DSL + # Docile.dsl_eval_with_block_return("Hello, world!") do + # reverse! + # upcase! + # first + # end + # #=> "!" + # @example Use an Array as a DSL + # Docile.dsl_eval_with_block_return([]) do + # push "a" + # push "b" + # pop + # push "c" + # length + # end + # #=> 2 + # @note Use with an *imperative* DSL (commands modify the context object) + # @param dsl [Object] context object whose methods make up the DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object + # @return [Object] the return value from executing the block + # + # source://docile-1.4.0/lib/docile.rb:87 + def dsl_eval_with_block_return(dsl, *args, &block); end + + class << self + # Execute a block in the context of an object whose methods represent the + # commands in a DSL. + # + # Use this method to execute an *imperative* DSL, which means that: + # + # 1. Each command mutates the state of the DSL context object + # 2. The return value of each command is ignored + # 3. The final return value is the original context object + # + # @example Use a String as a DSL + # Docile.dsl_eval("Hello, world!") do + # reverse! + # upcase! + # end + # #=> "!DLROW ,OLLEH" + # @example Use an Array as a DSL + # Docile.dsl_eval([]) do + # push 1 + # push 2 + # pop + # push 3 + # end + # #=> [1, 3] + # @note Use with an *imperative* DSL (commands modify the context object) + # @param dsl [Object] context object whose methods make up the DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object + # @return [Object] the `dsl` context object after executing the block + # + # source://docile-1.4.0/lib/docile.rb:45 + def dsl_eval(dsl, *args, &block); end + + # Execute a block in the context of an immutable object whose methods, + # and the methods of their return values, represent the commands in a DSL. + # + # Use this method to execute a *functional* DSL, which means that: + # + # 1. The original DSL context object is never mutated + # 2. Each command returns the next DSL context object + # 3. The final return value is the value returned by the last command + # + # @example Use a frozen String as a DSL + # Docile.dsl_eval_immutable("I'm immutable!".freeze) do + # reverse + # upcase + # end + # #=> "!ELBATUMMI M'I" + # @example Use a Float as a DSL + # Docile.dsl_eval_immutable(84.5) do + # fdiv(2) + # floor + # end + # #=> 42 + # @note Use with a *functional* DSL (commands return successor + # context objects) + # @param dsl [Object] immutable context object whose methods make up the + # initial DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object and successor return values + # @return [Object] the return value of the final command in the block + # + # source://docile-1.4.0/lib/docile.rb:128 + def dsl_eval_immutable(dsl, *args, &block); end + + # Execute a block in the context of an object whose methods represent the + # commands in a DSL, and return *the block's return value*. + # + # Use this method to execute an *imperative* DSL, which means that: + # + # 1. Each command mutates the state of the DSL context object + # 2. The return value of each command is ignored + # 3. The final return value is the original context object + # + # @example Use a String as a DSL + # Docile.dsl_eval_with_block_return("Hello, world!") do + # reverse! + # upcase! + # first + # end + # #=> "!" + # @example Use an Array as a DSL + # Docile.dsl_eval_with_block_return([]) do + # push "a" + # push "b" + # pop + # push "c" + # length + # end + # #=> 2 + # @note Use with an *imperative* DSL (commands modify the context object) + # @param dsl [Object] context object whose methods make up the DSL + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed against the + # `dsl` context object + # @return [Object] the return value from executing the block + # + # source://docile-1.4.0/lib/docile.rb:87 + def dsl_eval_with_block_return(dsl, *args, &block); end + end +end + +# This is used to remove entries pointing to Docile's source files +# from {Exception#backtrace} and {Exception#backtrace_locations}. +# +# If {NoMethodError} is caught then the exception object will be extended +# by this module to add filter functionalities. +# +# @api private +# +# source://docile-1.4.0/lib/docile/backtrace_filter.rb:11 +module Docile::BacktraceFilter + # @api private + # + # source://docile-1.4.0/lib/docile/backtrace_filter.rb:14 + def backtrace; end + + # @api private + # + # source://docile-1.4.0/lib/docile/backtrace_filter.rb:19 + def backtrace_locations; end +end + +# @api private +# +# source://docile-1.4.0/lib/docile/backtrace_filter.rb:12 +Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp) + +# Operates in the same manner as {FallbackContextProxy}, but replacing +# the primary `receiver` object with the result of each proxied method. +# +# This is useful for implementing DSL evaluation for immutable context +# objects. +# +# +# @api private +# @see Docile.dsl_eval_immutable +# +# source://docile-1.4.0/lib/docile/chaining_fallback_context_proxy.rb:19 +class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy + # Proxy methods as in {FallbackContextProxy#method_missing}, replacing + # `receiver` with the returned value. + # + # @api private + # + # source://docile-1.4.0/lib/docile/chaining_fallback_context_proxy.rb:20 + def method_missing(method, *args, &block); end +end + +# A namespace for functions relating to the execution of a block against a +# proxy object. +# +# @api private +# +# source://docile-1.4.0/lib/docile/execution.rb:8 +module Docile::Execution + private + + # Execute a block in the context of an object whose methods represent the + # commands in a DSL, using a specific proxy class. + # + # @api private + # @param dsl [Object] context object whose methods make up the + # (initial) DSL + # @param proxy_type [FallbackContextProxy, ChainingFallbackContextProxy] which class to instantiate as proxy context + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed + # @return [Object] the return value of the block + # + # source://docile-1.4.0/lib/docile/execution.rb:19 + def exec_in_proxy_context(dsl, proxy_type, *args, &block); end + + class << self + # Execute a block in the context of an object whose methods represent the + # commands in a DSL, using a specific proxy class. + # + # @api private + # @param dsl [Object] context object whose methods make up the + # (initial) DSL + # @param proxy_type [FallbackContextProxy, ChainingFallbackContextProxy] which class to instantiate as proxy context + # @param args [Array] arguments to be passed to the block + # @param block [Proc] the block of DSL commands to be executed + # @return [Object] the return value of the block + # + # source://docile-1.4.0/lib/docile/execution.rb:19 + def exec_in_proxy_context(dsl, proxy_type, *args, &block); end + end +end + +# A proxy object with a primary receiver as well as a secondary +# fallback receiver. +# +# Will attempt to forward all method calls first to the primary receiver, +# and then to the fallback receiver if the primary does not handle that +# method. +# +# This is useful for implementing DSL evaluation in the context of an object. +# +# +# @api private +# @see Docile.dsl_eval +# +# source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:20 +class Docile::FallbackContextProxy + # @api private + # @param receiver [Object] the primary proxy target to which all methods + # initially will be forwarded + # @param fallback [Object] the fallback proxy target to which any methods + # not handled by `receiver` will be forwarded + # @return [FallbackContextProxy] a new instance of FallbackContextProxy + # + # source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:46 + def initialize(receiver, fallback); end + + # @api private + # @return [Array] Instance variable names, excluding + # {NON_PROXIED_INSTANCE_VARIABLES} + # + # source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:85 + def instance_variables; end + + # Proxy all methods, excluding {NON_PROXIED_METHODS}, first to `receiver` + # and then to `fallback` if not found. + # + # @api private + # + # source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:91 + def method_missing(method, *args, &block); end +end + +# The set of methods which will **not** fallback from the block's context +# to the dsl object. +# +# @api private +# +# source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:30 +Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set) + +# The set of instance variables which are local to this object and hidden. +# All other instance variables will be copied in and out of this object +# from the scope in which this proxy was created. +# +# @api private +# +# source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:35 +Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set) + +# The set of methods which will **not** be proxied, but instead answered +# by this object directly. +# +# @api private +# +# source://docile-1.4.0/lib/docile/fallback_context_proxy.rb:23 +Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set) + +# The current version of this library +# +# source://docile-1.4.0/lib/docile/version.rb:5 +Docile::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/json@2.6.2.rbi b/sorbet/rbi/gems/json@2.6.2.rbi new file mode 100644 index 00000000..c551eee5 --- /dev/null +++ b/sorbet/rbi/gems/json@2.6.2.rbi @@ -0,0 +1,1545 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `json` gem. +# Please instead update this file by running `bin/tapioca gem json`. + +# Extends any Class to include _json_creatable?_ method. +# +# source://json-2.6.2/lib/json/common.rb:695 +class Class < ::Module + # Returns true if this class can be used to create an instance + # from a serialised JSON string. The class has to implement a class + # method _json_create_ that expects a hash as first parameter. The hash + # should include the required data. + # + # @return [Boolean] + # + # source://json-2.6.2/lib/json/common.rb:700 + def json_creatable?; end +end + +# = JavaScript \Object Notation (\JSON) +# +# \JSON is a lightweight data-interchange format. +# +# A \JSON value is one of the following: +# - Double-quoted text: "foo". +# - Number: +1+, +1.0+, +2.0e2+. +# - Boolean: +true+, +false+. +# - Null: +null+. +# - \Array: an ordered list of values, enclosed by square brackets: +# ["foo", 1, 1.0, 2.0e2, true, false, null] +# +# - \Object: a collection of name/value pairs, enclosed by curly braces; +# each name is double-quoted text; +# the values may be any \JSON values: +# {"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null} +# +# A \JSON array or object may contain nested arrays, objects, and scalars +# to any depth: +# {"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]} +# [{"foo": 0, "bar": 1}, ["baz", 2]] +# +# == Using \Module \JSON +# +# To make module \JSON available in your code, begin with: +# require 'json' +# +# All examples here assume that this has been done. +# +# === Parsing \JSON +# +# You can parse a \String containing \JSON data using +# either of two methods: +# - JSON.parse(source, opts) +# - JSON.parse!(source, opts) +# +# where +# - +source+ is a Ruby object. +# - +opts+ is a \Hash object containing options +# that control both input allowed and output formatting. +# +# The difference between the two methods +# is that JSON.parse! omits some checks +# and may not be safe for some +source+ data; +# use it only for data from trusted sources. +# Use the safer method JSON.parse for less trusted sources. +# +# ==== Parsing \JSON Arrays +# +# When +source+ is a \JSON array, JSON.parse by default returns a Ruby \Array: +# json = '["foo", 1, 1.0, 2.0e2, true, false, null]' +# ruby = JSON.parse(json) +# ruby # => ["foo", 1, 1.0, 200.0, true, false, nil] +# ruby.class # => Array +# +# The \JSON array may contain nested arrays, objects, and scalars +# to any depth: +# json = '[{"foo": 0, "bar": 1}, ["baz", 2]]' +# JSON.parse(json) # => [{"foo"=>0, "bar"=>1}, ["baz", 2]] +# +# ==== Parsing \JSON \Objects +# +# When the source is a \JSON object, JSON.parse by default returns a Ruby \Hash: +# json = '{"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}' +# ruby = JSON.parse(json) +# ruby # => {"a"=>"foo", "b"=>1, "c"=>1.0, "d"=>200.0, "e"=>true, "f"=>false, "g"=>nil} +# ruby.class # => Hash +# +# The \JSON object may contain nested arrays, objects, and scalars +# to any depth: +# json = '{"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}' +# JSON.parse(json) # => {"foo"=>{"bar"=>1, "baz"=>2}, "bat"=>[0, 1, 2]} +# +# ==== Parsing \JSON Scalars +# +# When the source is a \JSON scalar (not an array or object), +# JSON.parse returns a Ruby scalar. +# +# \String: +# ruby = JSON.parse('"foo"') +# ruby # => 'foo' +# ruby.class # => String +# \Integer: +# ruby = JSON.parse('1') +# ruby # => 1 +# ruby.class # => Integer +# \Float: +# ruby = JSON.parse('1.0') +# ruby # => 1.0 +# ruby.class # => Float +# ruby = JSON.parse('2.0e2') +# ruby # => 200 +# ruby.class # => Float +# Boolean: +# ruby = JSON.parse('true') +# ruby # => true +# ruby.class # => TrueClass +# ruby = JSON.parse('false') +# ruby # => false +# ruby.class # => FalseClass +# Null: +# ruby = JSON.parse('null') +# ruby # => nil +# ruby.class # => NilClass +# +# ==== Parsing Options +# +# ====== Input Options +# +# Option +max_nesting+ (\Integer) specifies the maximum nesting depth allowed; +# defaults to +100+; specify +false+ to disable depth checking. +# +# With the default, +false+: +# source = '[0, [1, [2, [3]]]]' +# ruby = JSON.parse(source) +# ruby # => [0, [1, [2, [3]]]] +# Too deep: +# # Raises JSON::NestingError (nesting of 2 is too deep): +# JSON.parse(source, {max_nesting: 1}) +# Bad value: +# # Raises TypeError (wrong argument type Symbol (expected Fixnum)): +# JSON.parse(source, {max_nesting: :foo}) +# +# --- +# +# Option +allow_nan+ (boolean) specifies whether to allow +# NaN, Infinity, and MinusInfinity in +source+; +# defaults to +false+. +# +# With the default, +false+: +# # Raises JSON::ParserError (225: unexpected token at '[NaN]'): +# JSON.parse('[NaN]') +# # Raises JSON::ParserError (232: unexpected token at '[Infinity]'): +# JSON.parse('[Infinity]') +# # Raises JSON::ParserError (248: unexpected token at '[-Infinity]'): +# JSON.parse('[-Infinity]') +# Allow: +# source = '[NaN, Infinity, -Infinity]' +# ruby = JSON.parse(source, {allow_nan: true}) +# ruby # => [NaN, Infinity, -Infinity] +# +# ====== Output Options +# +# Option +symbolize_names+ (boolean) specifies whether returned \Hash keys +# should be Symbols; +# defaults to +false+ (use Strings). +# +# With the default, +false+: +# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' +# ruby = JSON.parse(source) +# ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} +# Use Symbols: +# ruby = JSON.parse(source, {symbolize_names: true}) +# ruby # => {:a=>"foo", :b=>1.0, :c=>true, :d=>false, :e=>nil} +# +# --- +# +# Option +object_class+ (\Class) specifies the Ruby class to be used +# for each \JSON object; +# defaults to \Hash. +# +# With the default, \Hash: +# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' +# ruby = JSON.parse(source) +# ruby.class # => Hash +# Use class \OpenStruct: +# ruby = JSON.parse(source, {object_class: OpenStruct}) +# ruby # => # +# +# --- +# +# Option +array_class+ (\Class) specifies the Ruby class to be used +# for each \JSON array; +# defaults to \Array. +# +# With the default, \Array: +# source = '["foo", 1.0, true, false, null]' +# ruby = JSON.parse(source) +# ruby.class # => Array +# Use class \Set: +# ruby = JSON.parse(source, {array_class: Set}) +# ruby # => # +# +# --- +# +# Option +create_additions+ (boolean) specifies whether to use \JSON additions in parsing. +# See {\JSON Additions}[#module-JSON-label-JSON+Additions]. +# +# === Generating \JSON +# +# To generate a Ruby \String containing \JSON data, +# use method JSON.generate(source, opts), where +# - +source+ is a Ruby object. +# - +opts+ is a \Hash object containing options +# that control both input allowed and output formatting. +# +# ==== Generating \JSON from Arrays +# +# When the source is a Ruby \Array, JSON.generate returns +# a \String containing a \JSON array: +# ruby = [0, 's', :foo] +# json = JSON.generate(ruby) +# json # => '[0,"s","foo"]' +# +# The Ruby \Array array may contain nested arrays, hashes, and scalars +# to any depth: +# ruby = [0, [1, 2], {foo: 3, bar: 4}] +# json = JSON.generate(ruby) +# json # => '[0,[1,2],{"foo":3,"bar":4}]' +# +# ==== Generating \JSON from Hashes +# +# When the source is a Ruby \Hash, JSON.generate returns +# a \String containing a \JSON object: +# ruby = {foo: 0, bar: 's', baz: :bat} +# json = JSON.generate(ruby) +# json # => '{"foo":0,"bar":"s","baz":"bat"}' +# +# The Ruby \Hash array may contain nested arrays, hashes, and scalars +# to any depth: +# ruby = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} +# json = JSON.generate(ruby) +# json # => '{"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}' +# +# ==== Generating \JSON from Other Objects +# +# When the source is neither an \Array nor a \Hash, +# the generated \JSON data depends on the class of the source. +# +# When the source is a Ruby \Integer or \Float, JSON.generate returns +# a \String containing a \JSON number: +# JSON.generate(42) # => '42' +# JSON.generate(0.42) # => '0.42' +# +# When the source is a Ruby \String, JSON.generate returns +# a \String containing a \JSON string (with double-quotes): +# JSON.generate('A string') # => '"A string"' +# +# When the source is +true+, +false+ or +nil+, JSON.generate returns +# a \String containing the corresponding \JSON token: +# JSON.generate(true) # => 'true' +# JSON.generate(false) # => 'false' +# JSON.generate(nil) # => 'null' +# +# When the source is none of the above, JSON.generate returns +# a \String containing a \JSON string representation of the source: +# JSON.generate(:foo) # => '"foo"' +# JSON.generate(Complex(0, 0)) # => '"0+0i"' +# JSON.generate(Dir.new('.')) # => '"#"' +# +# ==== Generating Options +# +# ====== Input Options +# +# Option +allow_nan+ (boolean) specifies whether +# +NaN+, +Infinity+, and -Infinity may be generated; +# defaults to +false+. +# +# With the default, +false+: +# # Raises JSON::GeneratorError (920: NaN not allowed in JSON): +# JSON.generate(JSON::NaN) +# # Raises JSON::GeneratorError (917: Infinity not allowed in JSON): +# JSON.generate(JSON::Infinity) +# # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON): +# JSON.generate(JSON::MinusInfinity) +# +# Allow: +# ruby = [Float::NaN, Float::Infinity, Float::MinusInfinity] +# JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,-Infinity]' +# +# --- +# +# Option +max_nesting+ (\Integer) specifies the maximum nesting depth +# in +obj+; defaults to +100+. +# +# With the default, +100+: +# obj = [[[[[[0]]]]]] +# JSON.generate(obj) # => '[[[[[[0]]]]]]' +# +# Too deep: +# # Raises JSON::NestingError (nesting of 2 is too deep): +# JSON.generate(obj, max_nesting: 2) +# +# ====== Output Options +# +# The default formatting options generate the most compact +# \JSON data, all on one line and with no whitespace. +# +# You can use these formatting options to generate +# \JSON data in a more open format, using whitespace. +# See also JSON.pretty_generate. +# +# - Option +array_nl+ (\String) specifies a string (usually a newline) +# to be inserted after each \JSON array; defaults to the empty \String, ''. +# - Option +object_nl+ (\String) specifies a string (usually a newline) +# to be inserted after each \JSON object; defaults to the empty \String, ''. +# - Option +indent+ (\String) specifies the string (usually spaces) to be +# used for indentation; defaults to the empty \String, ''; +# defaults to the empty \String, ''; +# has no effect unless options +array_nl+ or +object_nl+ specify newlines. +# - Option +space+ (\String) specifies a string (usually a space) to be +# inserted after the colon in each \JSON object's pair; +# defaults to the empty \String, ''. +# - Option +space_before+ (\String) specifies a string (usually a space) to be +# inserted before the colon in each \JSON object's pair; +# defaults to the empty \String, ''. +# +# In this example, +obj+ is used first to generate the shortest +# \JSON data (no whitespace), then again with all formatting options +# specified: +# +# obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} +# json = JSON.generate(obj) +# puts 'Compact:', json +# opts = { +# array_nl: "\n", +# object_nl: "\n", +# indent: ' ', +# space_before: ' ', +# space: ' ' +# } +# puts 'Open:', JSON.generate(obj, opts) +# +# Output: +# Compact: +# {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}} +# Open: +# { +# "foo" : [ +# "bar", +# "baz" +# ], +# "bat" : { +# "bam" : 0, +# "bad" : 1 +# } +# } +# +# == \JSON Additions +# +# When you "round trip" a non-\String object from Ruby to \JSON and back, +# you have a new \String, instead of the object you began with: +# ruby0 = Range.new(0, 2) +# json = JSON.generate(ruby0) +# json # => '0..2"' +# ruby1 = JSON.parse(json) +# ruby1 # => '0..2' +# ruby1.class # => String +# +# You can use \JSON _additions_ to preserve the original object. +# The addition is an extension of a ruby class, so that: +# - \JSON.generate stores more information in the \JSON string. +# - \JSON.parse, called with option +create_additions+, +# uses that information to create a proper Ruby object. +# +# This example shows a \Range being generated into \JSON +# and parsed back into Ruby, both without and with +# the addition for \Range: +# ruby = Range.new(0, 2) +# # This passage does not use the addition for Range. +# json0 = JSON.generate(ruby) +# ruby0 = JSON.parse(json0) +# # This passage uses the addition for Range. +# require 'json/add/range' +# json1 = JSON.generate(ruby) +# ruby1 = JSON.parse(json1, create_additions: true) +# # Make a nice display. +# display = <require 'json/add/bigdecimal' +# - Complex: require 'json/add/complex' +# - Date: require 'json/add/date' +# - DateTime: require 'json/add/date_time' +# - Exception: require 'json/add/exception' +# - OpenStruct: require 'json/add/ostruct' +# - Range: require 'json/add/range' +# - Rational: require 'json/add/rational' +# - Regexp: require 'json/add/regexp' +# - Set: require 'json/add/set' +# - Struct: require 'json/add/struct' +# - Symbol: require 'json/add/symbol' +# - Time: require 'json/add/time' +# +# To reduce punctuation clutter, the examples below +# show the generated \JSON via +puts+, rather than the usual +inspect+, +# +# \BigDecimal: +# require 'json/add/bigdecimal' +# ruby0 = BigDecimal(0) # 0.0 +# json = JSON.generate(ruby0) # {"json_class":"BigDecimal","b":"27:0.0"} +# ruby1 = JSON.parse(json, create_additions: true) # 0.0 +# ruby1.class # => BigDecimal +# +# \Complex: +# require 'json/add/complex' +# ruby0 = Complex(1+0i) # 1+0i +# json = JSON.generate(ruby0) # {"json_class":"Complex","r":1,"i":0} +# ruby1 = JSON.parse(json, create_additions: true) # 1+0i +# ruby1.class # Complex +# +# \Date: +# require 'json/add/date' +# ruby0 = Date.today # 2020-05-02 +# json = JSON.generate(ruby0) # {"json_class":"Date","y":2020,"m":5,"d":2,"sg":2299161.0} +# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 +# ruby1.class # Date +# +# \DateTime: +# require 'json/add/date_time' +# ruby0 = DateTime.now # 2020-05-02T10:38:13-05:00 +# json = JSON.generate(ruby0) # {"json_class":"DateTime","y":2020,"m":5,"d":2,"H":10,"M":38,"S":13,"of":"-5/24","sg":2299161.0} +# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02T10:38:13-05:00 +# ruby1.class # DateTime +# +# \Exception (and its subclasses including \RuntimeError): +# require 'json/add/exception' +# ruby0 = Exception.new('A message') # A message +# json = JSON.generate(ruby0) # {"json_class":"Exception","m":"A message","b":null} +# ruby1 = JSON.parse(json, create_additions: true) # A message +# ruby1.class # Exception +# ruby0 = RuntimeError.new('Another message') # Another message +# json = JSON.generate(ruby0) # {"json_class":"RuntimeError","m":"Another message","b":null} +# ruby1 = JSON.parse(json, create_additions: true) # Another message +# ruby1.class # RuntimeError +# +# \OpenStruct: +# require 'json/add/ostruct' +# ruby0 = OpenStruct.new(name: 'Matz', language: 'Ruby') # # +# json = JSON.generate(ruby0) # {"json_class":"OpenStruct","t":{"name":"Matz","language":"Ruby"}} +# ruby1 = JSON.parse(json, create_additions: true) # # +# ruby1.class # OpenStruct +# +# \Range: +# require 'json/add/range' +# ruby0 = Range.new(0, 2) # 0..2 +# json = JSON.generate(ruby0) # {"json_class":"Range","a":[0,2,false]} +# ruby1 = JSON.parse(json, create_additions: true) # 0..2 +# ruby1.class # Range +# +# \Rational: +# require 'json/add/rational' +# ruby0 = Rational(1, 3) # 1/3 +# json = JSON.generate(ruby0) # {"json_class":"Rational","n":1,"d":3} +# ruby1 = JSON.parse(json, create_additions: true) # 1/3 +# ruby1.class # Rational +# +# \Regexp: +# require 'json/add/regexp' +# ruby0 = Regexp.new('foo') # (?-mix:foo) +# json = JSON.generate(ruby0) # {"json_class":"Regexp","o":0,"s":"foo"} +# ruby1 = JSON.parse(json, create_additions: true) # (?-mix:foo) +# ruby1.class # Regexp +# +# \Set: +# require 'json/add/set' +# ruby0 = Set.new([0, 1, 2]) # # +# json = JSON.generate(ruby0) # {"json_class":"Set","a":[0,1,2]} +# ruby1 = JSON.parse(json, create_additions: true) # # +# ruby1.class # Set +# +# \Struct: +# require 'json/add/struct' +# Customer = Struct.new(:name, :address) # Customer +# ruby0 = Customer.new("Dave", "123 Main") # # +# json = JSON.generate(ruby0) # {"json_class":"Customer","v":["Dave","123 Main"]} +# ruby1 = JSON.parse(json, create_additions: true) # # +# ruby1.class # Customer +# +# \Symbol: +# require 'json/add/symbol' +# ruby0 = :foo # foo +# json = JSON.generate(ruby0) # {"json_class":"Symbol","s":"foo"} +# ruby1 = JSON.parse(json, create_additions: true) # foo +# ruby1.class # Symbol +# +# \Time: +# require 'json/add/time' +# ruby0 = Time.now # 2020-05-02 11:28:26 -0500 +# json = JSON.generate(ruby0) # {"json_class":"Time","s":1588436906,"n":840560000} +# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 11:28:26 -0500 +# ruby1.class # Time +# +# +# === Custom \JSON Additions +# +# In addition to the \JSON additions provided, +# you can craft \JSON additions of your own, +# either for Ruby built-in classes or for user-defined classes. +# +# Here's a user-defined class +Foo+: +# class Foo +# attr_accessor :bar, :baz +# def initialize(bar, baz) +# self.bar = bar +# self.baz = baz +# end +# end +# +# Here's the \JSON addition for it: +# # Extend class Foo with JSON addition. +# class Foo +# # Serialize Foo object with its class name and arguments +# def to_json(*args) +# { +# JSON.create_id => self.class.name, +# 'a' => [ bar, baz ] +# }.to_json(*args) +# end +# # Deserialize JSON string by constructing new Foo object with arguments. +# def self.json_create(object) +# new(*object['a']) +# end +# end +# +# Demonstration: +# require 'json' +# # This Foo object has no custom addition. +# foo0 = Foo.new(0, 1) +# json0 = JSON.generate(foo0) +# obj0 = JSON.parse(json0) +# # Lood the custom addition. +# require_relative 'foo_addition' +# # This foo has the custom addition. +# foo1 = Foo.new(0, 1) +# json1 = JSON.generate(foo1) +# obj1 = JSON.parse(json1, create_additions: true) +# # Make a nice display. +# display = <" (String) +# With custom addition: {"json_class":"Foo","a":[0,1]} (String) +# Parsed JSON: +# Without custom addition: "#" (String) +# With custom addition: # (Foo) +# +# source://json-2.6.2/lib/json/version.rb:2 +module JSON + private + + # :call-seq: + # JSON.dump(obj, io = nil, limit = nil) + # + # Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result. + # + # The default options can be changed via method JSON.dump_default_options. + # + # - Argument +io+, if given, should respond to method +write+; + # the \JSON \String is written to +io+, and +io+ is returned. + # If +io+ is not given, the \JSON \String is returned. + # - Argument +limit+, if given, is passed to JSON.generate as option +max_nesting+. + # + # --- + # + # When argument +io+ is not given, returns the \JSON \String generated from +obj+: + # obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} + # json = JSON.dump(obj) + # json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}" + # + # When argument +io+ is given, writes the \JSON \String to +io+ and returns +io+: + # path = 't.json' + # File.open(path, 'w') do |file| + # JSON.dump(obj, file) + # end # => # + # puts File.read(path) + # Output: + # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} + # + # source://json-2.6.2/lib/json/common.rb:631 + def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end + + # :call-seq: + # JSON.fast_generate(obj, opts) -> new_string + # + # Arguments +obj+ and +opts+ here are the same as + # arguments +obj+ and +opts+ in JSON.generate. + # + # By default, generates \JSON data without checking + # for circular references in +obj+ (option +max_nesting+ set to +false+, disabled). + # + # Raises an exception if +obj+ contains circular references: + # a = []; b = []; a.push(b); b.push(a) + # # Raises SystemStackError (stack level too deep): + # JSON.fast_generate(a) + # + # source://json-2.6.2/lib/json/common.rb:335 + def fast_generate(obj, opts = T.unsafe(nil)); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and later delete them. + # + # source://json-2.6.2/lib/json/common.rb:335 + def fast_unparse(obj, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.generate(obj, opts = nil) -> new_string + # + # Returns a \String containing the generated \JSON data. + # + # See also JSON.fast_generate, JSON.pretty_generate. + # + # Argument +obj+ is the Ruby object to be converted to \JSON. + # + # Argument +opts+, if given, contains a \Hash of options for the generation. + # See {Generating Options}[#module-JSON-label-Generating+Options]. + # + # --- + # + # When +obj+ is an \Array, returns a \String containing a \JSON array: + # obj = ["foo", 1.0, true, false, nil] + # json = JSON.generate(obj) + # json # => '["foo",1.0,true,false,null]' + # + # When +obj+ is a \Hash, returns a \String containing a \JSON object: + # obj = {foo: 0, bar: 's', baz: :bat} + # json = JSON.generate(obj) + # json # => '{"foo":0,"bar":"s","baz":"bat"}' + # + # For examples of generating from other Ruby objects, see + # {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects]. + # + # --- + # + # Raises an exception if any formatting option is not a \String. + # + # Raises an exception if +obj+ contains circular references: + # a = []; b = []; a.push(b); b.push(a) + # # Raises JSON::NestingError (nesting of 100 is too deep): + # JSON.generate(a) + # + # source://json-2.6.2/lib/json/common.rb:296 + def generate(obj, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.load(source, proc = nil, options = {}) -> object + # + # Returns the Ruby objects created by parsing the given +source+. + # + # - Argument +source+ must be, or be convertible to, a \String: + # - If +source+ responds to instance method +to_str+, + # source.to_str becomes the source. + # - If +source+ responds to instance method +to_io+, + # source.to_io.read becomes the source. + # - If +source+ responds to instance method +read+, + # source.read becomes the source. + # - If both of the following are true, source becomes the \String 'null': + # - Option +allow_blank+ specifies a truthy value. + # - The source, as defined above, is +nil+ or the empty \String ''. + # - Otherwise, +source+ remains the source. + # - Argument +proc+, if given, must be a \Proc that accepts one argument. + # It will be called recursively with each result (depth-first order). + # See details below. + # BEWARE: This method is meant to serialise data from trusted user input, + # like from your own database server or clients under your control, it could + # be dangerous to allow untrusted users to pass JSON sources into it. + # - Argument +opts+, if given, contains a \Hash of options for the parsing. + # See {Parsing Options}[#module-JSON-label-Parsing+Options]. + # The default options can be changed via method JSON.load_default_options=. + # + # --- + # + # When no +proc+ is given, modifies +source+ as above and returns the result of + # parse(source, opts); see #parse. + # + # Source for following examples: + # source = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # + # Load a \String: + # ruby = JSON.load(source) + # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # Load an \IO object: + # require 'stringio' + # object = JSON.load(StringIO.new(source)) + # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # Load a \File object: + # path = 't.json' + # File.write(path, source) + # File.open(path) do |file| + # JSON.load(file) + # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # --- + # + # When +proc+ is given: + # - Modifies +source+ as above. + # - Gets the +result+ from calling parse(source, opts). + # - Recursively calls proc(result). + # - Returns the final result. + # + # Example: + # require 'json' + # + # # Some classes for the example. + # class Base + # def initialize(attributes) + # @attributes = attributes + # end + # end + # class User < Base; end + # class Account < Base; end + # class Admin < Base; end + # # The JSON source. + # json = <<-EOF + # { + # "users": [ + # {"type": "User", "username": "jane", "email": "jane@example.com"}, + # {"type": "User", "username": "john", "email": "john@example.com"} + # ], + # "accounts": [ + # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, + # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} + # ], + # "admins": {"type": "Admin", "password": "0wn3d"} + # } + # EOF + # # Deserializer method. + # def deserialize_obj(obj, safe_types = %w(User Account Admin)) + # type = obj.is_a?(Hash) && obj["type"] + # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj + # end + # # Call to JSON.load + # ruby = JSON.load(json, proc {|obj| + # case obj + # when Hash + # obj.each {|k, v| obj[k] = deserialize_obj v } + # when Array + # obj.map! {|v| deserialize_obj v } + # end + # }) + # pp ruby + # Output: + # {"users"=> + # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, + # #"User", "username"=>"john", "email"=>"john@example.com"}>], + # "accounts"=> + # [{"account"=> + # #"Account", "paid"=>true, "account_id"=>"1234"}>}, + # {"account"=> + # #"Account", "paid"=>false, "account_id"=>"1235"}>}], + # "admins"=> + # #"Admin", "password"=>"0wn3d"}>} + # + # source://json-2.6.2/lib/json/common.rb:557 + def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end + + # :call-seq: + # JSON.load_file(path, opts={}) -> object + # + # Calls: + # parse(File.read(path), opts) + # + # See method #parse. + # + # source://json-2.6.2/lib/json/common.rb:245 + def load_file(filespec, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.load_file!(path, opts = {}) + # + # Calls: + # JSON.parse!(File.read(path, opts)) + # + # See method #parse! + # + # source://json-2.6.2/lib/json/common.rb:256 + def load_file!(filespec, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.parse(source, opts) -> object + # + # Returns the Ruby objects created by parsing the given +source+. + # + # Argument +source+ contains the \String to be parsed. + # + # Argument +opts+, if given, contains a \Hash of options for the parsing. + # See {Parsing Options}[#module-JSON-label-Parsing+Options]. + # + # --- + # + # When +source+ is a \JSON array, returns a Ruby \Array: + # source = '["foo", 1.0, true, false, null]' + # ruby = JSON.parse(source) + # ruby # => ["foo", 1.0, true, false, nil] + # ruby.class # => Array + # + # When +source+ is a \JSON object, returns a Ruby \Hash: + # source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' + # ruby = JSON.parse(source) + # ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} + # ruby.class # => Hash + # + # For examples of parsing for all \JSON data types, see + # {Parsing \JSON}[#module-JSON-label-Parsing+JSON]. + # + # Parses nested JSON objects: + # source = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # ruby = JSON.parse(source) + # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # --- + # + # Raises an exception if +source+ is not valid JSON: + # # Raises JSON::ParserError (783: unexpected token at ''): + # JSON.parse('') + # + # source://json-2.6.2/lib/json/common.rb:215 + def parse(source, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.parse!(source, opts) -> object + # + # Calls + # parse(source, opts) + # with +source+ and possibly modified +opts+. + # + # Differences from JSON.parse: + # - Option +max_nesting+, if not provided, defaults to +false+, + # which disables checking for nesting depth. + # - Option +allow_nan+, if not provided, defaults to +true+. + # + # source://json-2.6.2/lib/json/common.rb:230 + def parse!(source, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.pretty_generate(obj, opts = nil) -> new_string + # + # Arguments +obj+ and +opts+ here are the same as + # arguments +obj+ and +opts+ in JSON.generate. + # + # Default options are: + # { + # indent: ' ', # Two spaces + # space: ' ', # One space + # array_nl: "\n", # Newline + # object_nl: "\n" # Newline + # } + # + # Example: + # obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} + # json = JSON.pretty_generate(obj) + # puts json + # Output: + # { + # "foo": [ + # "bar", + # "baz" + # ], + # "bat": { + # "bam": 0, + # "bad": 1 + # } + # } + # + # source://json-2.6.2/lib/json/common.rb:390 + def pretty_generate(obj, opts = T.unsafe(nil)); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and later delete them. + # + # source://json-2.6.2/lib/json/common.rb:390 + def pretty_unparse(obj, opts = T.unsafe(nil)); end + + # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_ + # + # source://json-2.6.2/lib/json/common.rb:575 + def recurse_proc(result, &proc); end + + # source://json-2.6.2/lib/json/common.rb:557 + def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and + # later delete them. + # + # source://json-2.6.2/lib/json/common.rb:296 + def unparse(obj, opts = T.unsafe(nil)); end + + class << self + # :call-seq: + # JSON[object] -> new_array or new_string + # + # If +object+ is a \String, + # calls JSON.parse with +object+ and +opts+ (see method #parse): + # json = '[0, 1, null]' + # JSON[json]# => [0, 1, nil] + # + # Otherwise, calls JSON.generate with +object+ and +opts+ (see method #generate): + # ruby = [0, 1, nil] + # JSON[ruby] # => '[0,1,null]' + # + # source://json-2.6.2/lib/json/common.rb:18 + def [](object, opts = T.unsafe(nil)); end + + # source://json-2.6.2/lib/json/common.rb:81 + def create_fast_state; end + + # Returns the current create identifier. + # See also JSON.create_id=. + # + # source://json-2.6.2/lib/json/common.rb:126 + def create_id; end + + # Sets create identifier, which is used to decide if the _json_create_ + # hook of a class should be called; initial value is +json_class+: + # JSON.create_id # => 'json_class' + # + # source://json-2.6.2/lib/json/common.rb:120 + def create_id=(new_value); end + + # source://json-2.6.2/lib/json/common.rb:91 + def create_pretty_state; end + + # Return the constant located at _path_. The format of _path_ has to be + # either ::A::B::C or A::B::C. In any case, A has to be located at the top + # level (absolute namespace path?). If there doesn't exist a constant at + # the given path, an ArgumentError is raised. + # + # source://json-2.6.2/lib/json/common.rb:42 + def deep_const_get(path); end + + # :call-seq: + # JSON.dump(obj, io = nil, limit = nil) + # + # Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result. + # + # The default options can be changed via method JSON.dump_default_options. + # + # - Argument +io+, if given, should respond to method +write+; + # the \JSON \String is written to +io+, and +io+ is returned. + # If +io+ is not given, the \JSON \String is returned. + # - Argument +limit+, if given, is passed to JSON.generate as option +max_nesting+. + # + # --- + # + # When argument +io+ is not given, returns the \JSON \String generated from +obj+: + # obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} + # json = JSON.dump(obj) + # json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}" + # + # When argument +io+ is given, writes the \JSON \String to +io+ and returns +io+: + # path = 't.json' + # File.open(path, 'w') do |file| + # JSON.dump(obj, file) + # end # => # + # puts File.read(path) + # Output: + # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} + # + # source://json-2.6.2/lib/json/common.rb:631 + def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil)); end + + # Sets or returns the default options for the JSON.dump method. + # Initially: + # opts = JSON.dump_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} + # + # source://json-2.6.2/lib/json/common.rb:596 + def dump_default_options; end + + # Sets or returns the default options for the JSON.dump method. + # Initially: + # opts = JSON.dump_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :escape_slash=>false} + # + # source://json-2.6.2/lib/json/common.rb:596 + def dump_default_options=(_arg0); end + + # :call-seq: + # JSON.fast_generate(obj, opts) -> new_string + # + # Arguments +obj+ and +opts+ here are the same as + # arguments +obj+ and +opts+ in JSON.generate. + # + # By default, generates \JSON data without checking + # for circular references in +obj+ (option +max_nesting+ set to +false+, disabled). + # + # Raises an exception if +obj+ contains circular references: + # a = []; b = []; a.push(b); b.push(a) + # # Raises SystemStackError (stack level too deep): + # JSON.fast_generate(a) + # + # source://json-2.6.2/lib/json/common.rb:335 + def fast_generate(obj, opts = T.unsafe(nil)); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and later delete them. + # + # source://json-2.6.2/lib/json/common.rb:335 + def fast_unparse(obj, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.generate(obj, opts = nil) -> new_string + # + # Returns a \String containing the generated \JSON data. + # + # See also JSON.fast_generate, JSON.pretty_generate. + # + # Argument +obj+ is the Ruby object to be converted to \JSON. + # + # Argument +opts+, if given, contains a \Hash of options for the generation. + # See {Generating Options}[#module-JSON-label-Generating+Options]. + # + # --- + # + # When +obj+ is an \Array, returns a \String containing a \JSON array: + # obj = ["foo", 1.0, true, false, nil] + # json = JSON.generate(obj) + # json # => '["foo",1.0,true,false,null]' + # + # When +obj+ is a \Hash, returns a \String containing a \JSON object: + # obj = {foo: 0, bar: 's', baz: :bat} + # json = JSON.generate(obj) + # json # => '{"foo":0,"bar":"s","baz":"bat"}' + # + # For examples of generating from other Ruby objects, see + # {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects]. + # + # --- + # + # Raises an exception if any formatting option is not a \String. + # + # Raises an exception if +obj+ contains circular references: + # a = []; b = []; a.push(b); b.push(a) + # # Raises JSON::NestingError (nesting of 100 is too deep): + # JSON.generate(a) + # + # source://json-2.6.2/lib/json/common.rb:296 + def generate(obj, opts = T.unsafe(nil)); end + + # Returns the JSON generator module that is used by JSON. This is + # either JSON::Ext::Generator or JSON::Pure::Generator: + # JSON.generator # => JSON::Ext::Generator + # + # source://json-2.6.2/lib/json/common.rb:103 + def generator; end + + # Set the module _generator_ to be used by JSON. + # + # source://json-2.6.2/lib/json/common.rb:58 + def generator=(generator); end + + # Encodes string using String.encode. + # + # source://json-2.6.2/lib/json/common.rb:653 + def iconv(to, from, string); end + + # :call-seq: + # JSON.load(source, proc = nil, options = {}) -> object + # + # Returns the Ruby objects created by parsing the given +source+. + # + # - Argument +source+ must be, or be convertible to, a \String: + # - If +source+ responds to instance method +to_str+, + # source.to_str becomes the source. + # - If +source+ responds to instance method +to_io+, + # source.to_io.read becomes the source. + # - If +source+ responds to instance method +read+, + # source.read becomes the source. + # - If both of the following are true, source becomes the \String 'null': + # - Option +allow_blank+ specifies a truthy value. + # - The source, as defined above, is +nil+ or the empty \String ''. + # - Otherwise, +source+ remains the source. + # - Argument +proc+, if given, must be a \Proc that accepts one argument. + # It will be called recursively with each result (depth-first order). + # See details below. + # BEWARE: This method is meant to serialise data from trusted user input, + # like from your own database server or clients under your control, it could + # be dangerous to allow untrusted users to pass JSON sources into it. + # - Argument +opts+, if given, contains a \Hash of options for the parsing. + # See {Parsing Options}[#module-JSON-label-Parsing+Options]. + # The default options can be changed via method JSON.load_default_options=. + # + # --- + # + # When no +proc+ is given, modifies +source+ as above and returns the result of + # parse(source, opts); see #parse. + # + # Source for following examples: + # source = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # + # Load a \String: + # ruby = JSON.load(source) + # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # Load an \IO object: + # require 'stringio' + # object = JSON.load(StringIO.new(source)) + # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # Load a \File object: + # path = 't.json' + # File.write(path, source) + # File.open(path) do |file| + # JSON.load(file) + # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # --- + # + # When +proc+ is given: + # - Modifies +source+ as above. + # - Gets the +result+ from calling parse(source, opts). + # - Recursively calls proc(result). + # - Returns the final result. + # + # Example: + # require 'json' + # + # # Some classes for the example. + # class Base + # def initialize(attributes) + # @attributes = attributes + # end + # end + # class User < Base; end + # class Account < Base; end + # class Admin < Base; end + # # The JSON source. + # json = <<-EOF + # { + # "users": [ + # {"type": "User", "username": "jane", "email": "jane@example.com"}, + # {"type": "User", "username": "john", "email": "john@example.com"} + # ], + # "accounts": [ + # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, + # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} + # ], + # "admins": {"type": "Admin", "password": "0wn3d"} + # } + # EOF + # # Deserializer method. + # def deserialize_obj(obj, safe_types = %w(User Account Admin)) + # type = obj.is_a?(Hash) && obj["type"] + # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj + # end + # # Call to JSON.load + # ruby = JSON.load(json, proc {|obj| + # case obj + # when Hash + # obj.each {|k, v| obj[k] = deserialize_obj v } + # when Array + # obj.map! {|v| deserialize_obj v } + # end + # }) + # pp ruby + # Output: + # {"users"=> + # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, + # #"User", "username"=>"john", "email"=>"john@example.com"}>], + # "accounts"=> + # [{"account"=> + # #"Account", "paid"=>true, "account_id"=>"1234"}>}, + # {"account"=> + # #"Account", "paid"=>false, "account_id"=>"1235"}>}], + # "admins"=> + # #"Admin", "password"=>"0wn3d"}>} + # + # source://json-2.6.2/lib/json/common.rb:557 + def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end + + # Sets or returns default options for the JSON.load method. + # Initially: + # opts = JSON.load_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true} + # + # source://json-2.6.2/lib/json/common.rb:420 + def load_default_options; end + + # Sets or returns default options for the JSON.load method. + # Initially: + # opts = JSON.load_default_options + # opts # => {:max_nesting=>false, :allow_nan=>true, :allow_blank=>true, :create_additions=>true} + # + # source://json-2.6.2/lib/json/common.rb:420 + def load_default_options=(_arg0); end + + # :call-seq: + # JSON.load_file(path, opts={}) -> object + # + # Calls: + # parse(File.read(path), opts) + # + # See method #parse. + # + # source://json-2.6.2/lib/json/common.rb:245 + def load_file(filespec, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.load_file!(path, opts = {}) + # + # Calls: + # JSON.parse!(File.read(path, opts)) + # + # See method #parse! + # + # source://json-2.6.2/lib/json/common.rb:256 + def load_file!(filespec, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.parse(source, opts) -> object + # + # Returns the Ruby objects created by parsing the given +source+. + # + # Argument +source+ contains the \String to be parsed. + # + # Argument +opts+, if given, contains a \Hash of options for the parsing. + # See {Parsing Options}[#module-JSON-label-Parsing+Options]. + # + # --- + # + # When +source+ is a \JSON array, returns a Ruby \Array: + # source = '["foo", 1.0, true, false, null]' + # ruby = JSON.parse(source) + # ruby # => ["foo", 1.0, true, false, nil] + # ruby.class # => Array + # + # When +source+ is a \JSON object, returns a Ruby \Hash: + # source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' + # ruby = JSON.parse(source) + # ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} + # ruby.class # => Hash + # + # For examples of parsing for all \JSON data types, see + # {Parsing \JSON}[#module-JSON-label-Parsing+JSON]. + # + # Parses nested JSON objects: + # source = <<-EOT + # { + # "name": "Dave", + # "age" :40, + # "hats": [ + # "Cattleman's", + # "Panama", + # "Tophat" + # ] + # } + # EOT + # ruby = JSON.parse(source) + # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} + # + # --- + # + # Raises an exception if +source+ is not valid JSON: + # # Raises JSON::ParserError (783: unexpected token at ''): + # JSON.parse('') + # + # source://json-2.6.2/lib/json/common.rb:215 + def parse(source, opts = T.unsafe(nil)); end + + # :call-seq: + # JSON.parse!(source, opts) -> object + # + # Calls + # parse(source, opts) + # with +source+ and possibly modified +opts+. + # + # Differences from JSON.parse: + # - Option +max_nesting+, if not provided, defaults to +false+, + # which disables checking for nesting depth. + # - Option +allow_nan+, if not provided, defaults to +true+. + # + # source://json-2.6.2/lib/json/common.rb:230 + def parse!(source, opts = T.unsafe(nil)); end + + # Returns the JSON parser class that is used by JSON. This is either + # JSON::Ext::Parser or JSON::Pure::Parser: + # JSON.parser # => JSON::Ext::Parser + # + # source://json-2.6.2/lib/json/common.rb:29 + def parser; end + + # Set the JSON parser class _parser_ to be used by JSON. + # + # source://json-2.6.2/lib/json/common.rb:32 + def parser=(parser); end + + # :call-seq: + # JSON.pretty_generate(obj, opts = nil) -> new_string + # + # Arguments +obj+ and +opts+ here are the same as + # arguments +obj+ and +opts+ in JSON.generate. + # + # Default options are: + # { + # indent: ' ', # Two spaces + # space: ' ', # One space + # array_nl: "\n", # Newline + # object_nl: "\n" # Newline + # } + # + # Example: + # obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} + # json = JSON.pretty_generate(obj) + # puts json + # Output: + # { + # "foo": [ + # "bar", + # "baz" + # ], + # "bat": { + # "bam": 0, + # "bad": 1 + # } + # } + # + # source://json-2.6.2/lib/json/common.rb:390 + def pretty_generate(obj, opts = T.unsafe(nil)); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and later delete them. + # + # source://json-2.6.2/lib/json/common.rb:390 + def pretty_unparse(obj, opts = T.unsafe(nil)); end + + # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_ + # + # source://json-2.6.2/lib/json/common.rb:575 + def recurse_proc(result, &proc); end + + # source://json-2.6.2/lib/json/common.rb:557 + def restore(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end + + # Sets or Returns the JSON generator state class that is used by JSON. This is + # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: + # JSON.state # => JSON::Ext::Generator::State + # + # source://json-2.6.2/lib/json/common.rb:108 + def state; end + + # Sets or Returns the JSON generator state class that is used by JSON. This is + # either JSON::Ext::Generator::State or JSON::Pure::Generator::State: + # JSON.state # => JSON::Ext::Generator::State + # + # source://json-2.6.2/lib/json/common.rb:108 + def state=(_arg0); end + + # :stopdoc: + # I want to deprecate these later, so I'll first be silent about them, and + # later delete them. + # + # source://json-2.6.2/lib/json/common.rb:296 + def unparse(obj, opts = T.unsafe(nil)); end + end +end + +# source://json-2.6.2/lib/json/common.rb:114 +JSON::CREATE_ID_TLS_KEY = T.let(T.unsafe(nil), String) + +# source://json-2.6.2/lib/json/common.rb:111 +JSON::DEFAULT_CREATE_ID = T.let(T.unsafe(nil), String) + +# source://json-2.6.2/lib/json/generic_object.rb:5 +class JSON::GenericObject < ::OpenStruct + # source://json-2.6.2/lib/json/generic_object.rb:63 + def as_json(*_arg0); end + + # source://json-2.6.2/lib/json/generic_object.rb:47 + def to_hash; end + + # source://json-2.6.2/lib/json/generic_object.rb:67 + def to_json(*a); end + + # source://json-2.6.2/lib/json/generic_object.rb:59 + def |(other); end + + class << self + # source://json-2.6.2/lib/json/generic_object.rb:41 + def dump(obj, *args); end + + # source://json-2.6.2/lib/json/generic_object.rb:21 + def from_hash(object); end + + # Sets the attribute json_creatable + # + # @param value the value to set the attribute json_creatable to. + # + # source://json-2.6.2/lib/json/generic_object.rb:13 + def json_creatable=(_arg0); end + + # @return [Boolean] + # + # source://json-2.6.2/lib/json/generic_object.rb:9 + def json_creatable?; end + + # source://json-2.6.2/lib/json/generic_object.rb:15 + def json_create(data); end + + # source://json-2.6.2/lib/json/generic_object.rb:36 + def load(source, proc = T.unsafe(nil), opts = T.unsafe(nil)); end + end +end + +# The base exception for JSON errors. +# +# source://json-2.6.2/lib/json/common.rb:137 +class JSON::JSONError < ::StandardError + class << self + # source://json-2.6.2/lib/json/common.rb:138 + def wrap(exception); end + end +end + +# source://json-2.6.2/lib/json/common.rb:35 +JSON::Parser = JSON::Ext::Parser + +# source://json-2.6.2/lib/json/common.rb:73 +JSON::State = JSON::Ext::Generator::State + +# For backwards compatibility +# +# source://json-2.6.2/lib/json/common.rb:159 +JSON::UnparserError = JSON::GeneratorError + +# Adds a `byebug` method to the Kernel module. +# +# Dropping a `byebug` call anywhere in your code, you get a debug prompt. +# +# source://json-2.6.2/lib/json/common.rb:658 +module Kernel + private + + # If _object_ is string-like, parse the string and return the parsed result as + # a Ruby data structure. Otherwise, generate a JSON text from the Ruby data + # structure object and return it. + # + # The _opts_ argument is passed through to generate/parse respectively. See + # generate and parse for their documentation. + # + # source://json-2.6.2/lib/json/common.rb:685 + def JSON(object, *args); end + + # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in + # one line. + # + # source://json-2.6.2/lib/json/common.rb:663 + def j(*objs); end + + # Outputs _objs_ to STDOUT as JSON strings in a pretty format, with + # indentation and over many lines. + # + # source://json-2.6.2/lib/json/common.rb:672 + def jj(*objs); end +end diff --git a/sorbet/rbi/gems/method_source.rbi b/sorbet/rbi/gems/method_source.rbi deleted file mode 100644 index 92cdecdb..00000000 --- a/sorbet/rbi/gems/method_source.rbi +++ /dev/null @@ -1,64 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/method_source/all/method_source.rbi -# -# method_source-1.0.0 - -module MethodSource - def self.comment_helper(source_location, name = nil); end - def self.extract_code(source_location); end - def self.lines_for(file_name, name = nil); end - def self.source_helper(source_location, name = nil); end - def self.valid_expression?(str); end - extend MethodSource::CodeHelpers -end -module MethodSource::ReeSourceLocation - def source_location; end -end -module MethodSource::SourceLocation -end -module MethodSource::SourceLocation::MethodExtensions - def source_location; end - def trace_func(event, file, line, id, binding, classname); end -end -module MethodSource::SourceLocation::ProcExtensions - def source_location; end -end -module MethodSource::SourceLocation::UnboundMethodExtensions - def source_location; end -end -module MethodSource::CodeHelpers - def comment_describing(file, line_number); end - def complete_expression?(str); end - def expression_at(file, line_number, options = nil); end - def extract_first_expression(lines, consume = nil, &block); end - def extract_last_comment(lines); end -end -module MethodSource::CodeHelpers::IncompleteExpression - def self.===(ex); end - def self.rbx?; end -end -class MethodSource::SourceNotFoundError < StandardError -end -module MethodSource::MethodExtensions - def comment; end - def self.included(klass); end - def source; end -end -class Method - include MethodSource::MethodExtensions - include MethodSource::SourceLocation::MethodExtensions -end -class UnboundMethod - include MethodSource::MethodExtensions - include MethodSource::SourceLocation::UnboundMethodExtensions -end -class Proc - include MethodSource::MethodExtensions - include MethodSource::SourceLocation::ProcExtensions -end diff --git a/sorbet/rbi/gems/method_source@1.0.0.rbi b/sorbet/rbi/gems/method_source@1.0.0.rbi new file mode 100644 index 00000000..462f0f40 --- /dev/null +++ b/sorbet/rbi/gems/method_source@1.0.0.rbi @@ -0,0 +1,272 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `method_source` gem. +# Please instead update this file by running `bin/tapioca gem method_source`. + +# source://method_source-1.0.0/lib/method_source.rb:127 +class Method + include ::MethodSource::SourceLocation::MethodExtensions + include ::MethodSource::MethodExtensions +end + +# source://method_source-1.0.0/lib/method_source/version.rb:1 +module MethodSource + extend ::MethodSource::CodeHelpers + + class << self + # Helper method responsible for opening source file and buffering up + # the comments for a specified method. Defined here to avoid polluting + # `Method` class. + # + # @param source_location [Array] The array returned by Method#source_location + # @param method_name [String] + # @raise [SourceNotFoundError] + # @return [String] The comments up to the point of the method. + # + # source://method_source-1.0.0/lib/method_source.rb:38 + def comment_helper(source_location, name = T.unsafe(nil)); end + + # @deprecated — use MethodSource::CodeHelpers#expression_at + # + # source://method_source-1.0.0/lib/method_source.rb:66 + def extract_code(source_location); end + + # Load a memoized copy of the lines in a file. + # + # @param file_name [String] + # @param method_name [String] + # @raise [SourceNotFoundError] + # @return [Array] the contents of the file + # + # source://method_source-1.0.0/lib/method_source.rb:51 + def lines_for(file_name, name = T.unsafe(nil)); end + + # Helper method responsible for extracting method body. + # Defined here to avoid polluting `Method` class. + # + # @param source_location [Array] The array returned by Method#source_location + # @param method_name [String] + # @return [String] The method body + # + # source://method_source-1.0.0/lib/method_source.rb:23 + def source_helper(source_location, name = T.unsafe(nil)); end + + # @deprecated — use MethodSource::CodeHelpers#complete_expression? + # @return [Boolean] + # + # source://method_source-1.0.0/lib/method_source.rb:59 + def valid_expression?(str); end + end +end + +# source://method_source-1.0.0/lib/method_source/code_helpers.rb:3 +module MethodSource::CodeHelpers + # Retrieve the comment describing the expression on the given line of the given file. + # + # This is useful to get module or method documentation. + # + # @param file [Array, File, String] The file to parse, either as a File or as + # a String or an Array of lines. + # @param line_number [Integer] The line number at which to look. + # NOTE: The first line in a file is line 1! + # @return [String] The comment + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:52 + def comment_describing(file, line_number); end + + # Determine if a string of code is a complete Ruby expression. + # + # @example + # complete_expression?("class Hello") #=> false + # complete_expression?("class Hello; end") #=> true + # complete_expression?("class 123") #=> SyntaxError: unexpected tINTEGER + # @param code [String] The code to validate. + # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness. + # @return [Boolean] Whether or not the code is a complete Ruby expression. + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:66 + def complete_expression?(str); end + + # Retrieve the first expression starting on the given line of the given file. + # + # This is useful to get module or method source code. + # + # line 1! + # + # @option options + # @option options + # @param file [Array, File, String] The file to parse, either as a File or as + # @param line_number [Integer] The line number at which to look. + # NOTE: The first line in a file is + # @param options [Hash] The optional configuration parameters. + # @raise [SyntaxError] If the first complete expression can't be identified + # @return [String] The first complete expression + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:20 + def expression_at(file, line_number, options = T.unsafe(nil)); end + + private + + # Get the first expression from the input. + # + # @param lines [Array] + # @param consume [Integer] A number of lines to automatically + # consume (add to the expression buffer) without checking for validity. + # @raise [SyntaxError] + # @return [String] a valid ruby expression + # @yield a clean-up function to run before checking for complete_expression + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:92 + def extract_first_expression(lines, consume = T.unsafe(nil), &block); end + + # Get the last comment from the input. + # + # @param lines [Array] + # @return [String] + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:106 + def extract_last_comment(lines); end +end + +# An exception matcher that matches only subsets of SyntaxErrors that can be +# fixed by adding more input to the buffer. +# +# source://method_source-1.0.0/lib/method_source/code_helpers.rb:124 +module MethodSource::CodeHelpers::IncompleteExpression + class << self + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:137 + def ===(ex); end + + # @return [Boolean] + # + # source://method_source-1.0.0/lib/method_source/code_helpers.rb:149 + def rbx?; end + end +end + +# source://method_source-1.0.0/lib/method_source/code_helpers.rb:125 +MethodSource::CodeHelpers::IncompleteExpression::GENERIC_REGEXPS = T.let(T.unsafe(nil), Array) + +# source://method_source-1.0.0/lib/method_source/code_helpers.rb:133 +MethodSource::CodeHelpers::IncompleteExpression::RBX_ONLY_REGEXPS = T.let(T.unsafe(nil), Array) + +# This module is to be included by `Method` and `UnboundMethod` and +# provides the `#source` functionality +# +# source://method_source-1.0.0/lib/method_source.rb:72 +module MethodSource::MethodExtensions + # Return the comments associated with the method as a string. + # + # @example + # Set.instance_method(:clear).comment.display + # => + # # Removes all elements and returns self. + # @raise SourceNotFoundException + # @return [String] The method's comments as a string + # + # source://method_source-1.0.0/lib/method_source.rb:121 + def comment; end + + # Return the sourcecode for the method as a string + # + # @example + # Set.instance_method(:clear).source.display + # => + # def clear + # @hash.clear + # self + # end + # @raise SourceNotFoundException + # @return [String] The method sourcecode as a string + # + # source://method_source-1.0.0/lib/method_source.rb:109 + def source; end + + class << self + # We use the included hook to patch Method#source on rubinius. + # We need to use the included hook as Rubinius defines a `source` + # on Method so including a module will have no effect (as it's + # higher up the MRO). + # + # @param klass [Class] The class that includes the module. + # + # source://method_source-1.0.0/lib/method_source.rb:79 + def included(klass); end + end +end + +# source://method_source-1.0.0/lib/method_source/source_location.rb:2 +module MethodSource::ReeSourceLocation + # Ruby enterprise edition provides all the information that's + # needed, in a slightly different way. + # + # source://method_source-1.0.0/lib/method_source/source_location.rb:5 + def source_location; end +end + +# source://method_source-1.0.0/lib/method_source/source_location.rb:10 +module MethodSource::SourceLocation; end + +# source://method_source-1.0.0/lib/method_source/source_location.rb:11 +module MethodSource::SourceLocation::MethodExtensions + # Return the source location of a method for Ruby 1.8. + # + # @return [Array] A two element array. First element is the + # file, second element is the line in the file where the + # method definition is found. + # + # source://method_source-1.0.0/lib/method_source/source_location.rb:40 + def source_location; end + + private + + # source://method_source-1.0.0/lib/method_source/source_location.rb:26 + def trace_func(event, file, line, id, binding, classname); end +end + +# source://method_source-1.0.0/lib/method_source/source_location.rb:54 +module MethodSource::SourceLocation::ProcExtensions + # Return the source location for a Proc (in implementations + # without Proc#source_location) + # + # @return [Array] A two element array. First element is the + # file, second element is the line in the file where the + # proc definition is found. + # + # source://method_source-1.0.0/lib/method_source/source_location.rb:74 + def source_location; end +end + +# source://method_source-1.0.0/lib/method_source/source_location.rb:81 +module MethodSource::SourceLocation::UnboundMethodExtensions + # Return the source location of an instance method for Ruby 1.8. + # + # @return [Array] A two element array. First element is the + # file, second element is the line in the file where the + # method definition is found. + # + # source://method_source-1.0.0/lib/method_source/source_location.rb:101 + def source_location; end +end + +# An Exception to mark errors that were raised trying to find the source from +# a given source_location. +# +# source://method_source-1.0.0/lib/method_source.rb:16 +class MethodSource::SourceNotFoundError < ::StandardError; end + +# source://method_source-1.0.0/lib/method_source/version.rb:2 +MethodSource::VERSION = T.let(T.unsafe(nil), String) + +# source://method_source-1.0.0/lib/method_source.rb:137 +class Proc + include ::MethodSource::SourceLocation::ProcExtensions + include ::MethodSource::MethodExtensions +end + +# source://method_source-1.0.0/lib/method_source.rb:132 +class UnboundMethod + include ::MethodSource::SourceLocation::UnboundMethodExtensions + include ::MethodSource::MethodExtensions +end diff --git a/sorbet/rbi/gems/netrc@0.11.0.rbi b/sorbet/rbi/gems/netrc@0.11.0.rbi new file mode 100644 index 00000000..bec576db --- /dev/null +++ b/sorbet/rbi/gems/netrc@0.11.0.rbi @@ -0,0 +1,153 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `netrc` gem. +# Please instead update this file by running `bin/tapioca gem netrc`. + +# source://netrc-0.11.0/lib/netrc.rb:3 +class Netrc + # @return [Netrc] a new instance of Netrc + # + # source://netrc-0.11.0/lib/netrc.rb:166 + def initialize(path, data); end + + # source://netrc-0.11.0/lib/netrc.rb:180 + def [](k); end + + # source://netrc-0.11.0/lib/netrc.rb:188 + def []=(k, info); end + + # source://netrc-0.11.0/lib/netrc.rb:200 + def delete(key); end + + # source://netrc-0.11.0/lib/netrc.rb:211 + def each(&block); end + + # source://netrc-0.11.0/lib/netrc.rb:196 + def length; end + + # source://netrc-0.11.0/lib/netrc.rb:215 + def new_item(m, l, p); end + + # Returns the value of attribute new_item_prefix. + # + # source://netrc-0.11.0/lib/netrc.rb:178 + def new_item_prefix; end + + # Sets the attribute new_item_prefix + # + # @param value the value to set the attribute new_item_prefix to. + # + # source://netrc-0.11.0/lib/netrc.rb:178 + def new_item_prefix=(_arg0); end + + # source://netrc-0.11.0/lib/netrc.rb:219 + def save; end + + # source://netrc-0.11.0/lib/netrc.rb:233 + def unparse; end + + class << self + # source://netrc-0.11.0/lib/netrc.rb:42 + def check_permissions(path); end + + # source://netrc-0.11.0/lib/netrc.rb:33 + def config; end + + # @yield [self.config] + # + # source://netrc-0.11.0/lib/netrc.rb:37 + def configure; end + + # source://netrc-0.11.0/lib/netrc.rb:10 + def default_path; end + + # source://netrc-0.11.0/lib/netrc.rb:14 + def home_path; end + + # source://netrc-0.11.0/lib/netrc.rb:85 + def lex(lines); end + + # source://netrc-0.11.0/lib/netrc.rb:29 + def netrc_filename; end + + # Returns two values, a header and a list of items. + # Each item is a tuple, containing some or all of: + # - machine keyword (including trailing whitespace+comments) + # - machine name + # - login keyword (including surrounding whitespace+comments) + # - login + # - password keyword (including surrounding whitespace+comments) + # - password + # - trailing chars + # This lets us change individual fields, then write out the file + # with all its original formatting. + # + # source://netrc-0.11.0/lib/netrc.rb:129 + def parse(ts); end + + # Reads path and parses it as a .netrc file. If path doesn't + # exist, returns an empty object. Decrypt paths ending in .gpg. + # + # source://netrc-0.11.0/lib/netrc.rb:51 + def read(path = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://netrc-0.11.0/lib/netrc.rb:112 + def skip?(s); end + end +end + +# source://netrc-0.11.0/lib/netrc.rb:244 +class Netrc::Entry < ::Struct + # Returns the value of attribute login + # + # @return [Object] the current value of login + def login; end + + # Sets the attribute login + # + # @param value [Object] the value to set the attribute login to. + # @return [Object] the newly set value + # + # source://netrc-0.11.0/lib/netrc.rb:244 + def login=(_); end + + # Returns the value of attribute password + # + # @return [Object] the current value of password + def password; end + + # Sets the attribute password + # + # @param value [Object] the value to set the attribute password to. + # @return [Object] the newly set value + # + # source://netrc-0.11.0/lib/netrc.rb:244 + def password=(_); end + + def to_ary; end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://netrc-0.11.0/lib/netrc.rb:250 +class Netrc::Error < ::StandardError; end + +# source://netrc-0.11.0/lib/netrc.rb:68 +class Netrc::TokenArray < ::Array + # source://netrc-0.11.0/lib/netrc.rb:76 + def readto; end + + # source://netrc-0.11.0/lib/netrc.rb:69 + def take; end +end + +# source://netrc-0.11.0/lib/netrc.rb:4 +Netrc::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/parallel.rbi b/sorbet/rbi/gems/parallel.rbi deleted file mode 100644 index ce935248..00000000 --- a/sorbet/rbi/gems/parallel.rbi +++ /dev/null @@ -1,86 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parallel/all/parallel.rbi -# -# parallel-1.22.1 - -module Parallel - def self.add_progress_bar!(job_factory, options); end - def self.all?(*args, &block); end - def self.any?(*args, &block); end - def self.call_with_index(item, index, options, &block); end - def self.create_workers(job_factory, options, &block); end - def self.each(array, options = nil, &block); end - def self.each_with_index(array, options = nil, &block); end - def self.extract_count_from_options(options); end - def self.flat_map(*args, &block); end - def self.in_processes(options = nil, &block); end - def self.in_threads(options = nil); end - def self.instrument_finish(item, index, result, options); end - def self.instrument_start(item, index, options); end - def self.map(source, options = nil, &block); end - def self.map_with_index(array, options = nil, &block); end - def self.process_incoming_jobs(read, write, job_factory, options, &block); end - def self.replace_worker(job_factory, workers, index, options, blk); end - def self.with_instrumentation(item, index, options); end - def self.work_direct(job_factory, options, &block); end - def self.work_in_processes(job_factory, options, &blk); end - def self.work_in_ractors(job_factory, options); end - def self.work_in_threads(job_factory, options, &block); end - def self.worker(job_factory, options, &block); end - def self.worker_number; end - def self.worker_number=(worker_num); end - extend Parallel::ProcessorCount -end -module Parallel::ProcessorCount - def physical_processor_count; end - def processor_count; end -end -class Parallel::DeadWorker < StandardError -end -class Parallel::Break < StandardError - def initialize(value = nil); end - def value; end -end -class Parallel::Kill < Parallel::Break -end -class Parallel::UndumpableException < StandardError - def backtrace; end - def initialize(original); end -end -class Parallel::ExceptionWrapper - def exception; end - def initialize(exception); end -end -class Parallel::Worker - def close_pipes; end - def initialize(read, write, pid); end - def pid; end - def read; end - def stop; end - def thread; end - def thread=(arg0); end - def wait; end - def work(data); end - def write; end -end -class Parallel::JobFactory - def initialize(source, mutex); end - def next; end - def pack(item, index); end - def producer?; end - def queue_wrapper(array); end - def size; end - def unpack(data); end -end -class Parallel::UserInterruptHandler - def self.kill(thing); end - def self.kill_on_ctrl_c(pids, options); end - def self.restore_interrupt(old, signal); end - def self.trap_interrupt(signal); end -end diff --git a/sorbet/rbi/gems/parallel@1.22.1.rbi b/sorbet/rbi/gems/parallel@1.22.1.rbi new file mode 100644 index 00000000..4b356efc --- /dev/null +++ b/sorbet/rbi/gems/parallel@1.22.1.rbi @@ -0,0 +1,277 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `parallel` gem. +# Please instead update this file by running `bin/tapioca gem parallel`. + +# source://parallel-1.22.1/lib/parallel/version.rb:2 +module Parallel + extend ::Parallel::ProcessorCount + + class << self + # @return [Boolean] + # + # source://parallel-1.22.1/lib/parallel.rb:246 + def all?(*args, &block); end + + # @return [Boolean] + # + # source://parallel-1.22.1/lib/parallel.rb:241 + def any?(*args, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:237 + def each(array, options = T.unsafe(nil), &block); end + + # source://parallel-1.22.1/lib/parallel.rb:251 + def each_with_index(array, options = T.unsafe(nil), &block); end + + # source://parallel-1.22.1/lib/parallel.rb:306 + def flat_map(*args, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:231 + def in_processes(options = T.unsafe(nil), &block); end + + # source://parallel-1.22.1/lib/parallel.rb:215 + def in_threads(options = T.unsafe(nil)); end + + # source://parallel-1.22.1/lib/parallel.rb:255 + def map(source, options = T.unsafe(nil), &block); end + + # source://parallel-1.22.1/lib/parallel.rb:302 + def map_with_index(array, options = T.unsafe(nil), &block); end + + # source://parallel-1.22.1/lib/parallel.rb:310 + def worker_number; end + + # TODO: this does not work when doing threads in forks, so should remove and yield the number instead if needed + # + # source://parallel-1.22.1/lib/parallel.rb:315 + def worker_number=(worker_num); end + + private + + # source://parallel-1.22.1/lib/parallel.rb:321 + def add_progress_bar!(job_factory, options); end + + # source://parallel-1.22.1/lib/parallel.rb:584 + def call_with_index(item, index, options, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:516 + def create_workers(job_factory, options, &block); end + + # options is either a Integer or a Hash with :count + # + # source://parallel-1.22.1/lib/parallel.rb:574 + def extract_count_from_options(options); end + + # source://parallel-1.22.1/lib/parallel.rb:602 + def instrument_finish(item, index, result, options); end + + # source://parallel-1.22.1/lib/parallel.rb:607 + def instrument_start(item, index, options); end + + # source://parallel-1.22.1/lib/parallel.rb:550 + def process_incoming_jobs(read, write, job_factory, options, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:504 + def replace_worker(job_factory, workers, index, options, blk); end + + # source://parallel-1.22.1/lib/parallel.rb:595 + def with_instrumentation(item, index, options); end + + # source://parallel-1.22.1/lib/parallel.rb:346 + def work_direct(job_factory, options, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:456 + def work_in_processes(job_factory, options, &blk); end + + # source://parallel-1.22.1/lib/parallel.rb:390 + def work_in_ractors(job_factory, options); end + + # source://parallel-1.22.1/lib/parallel.rb:365 + def work_in_threads(job_factory, options, &block); end + + # source://parallel-1.22.1/lib/parallel.rb:524 + def worker(job_factory, options, &block); end + end +end + +# source://parallel-1.22.1/lib/parallel.rb:14 +class Parallel::Break < ::StandardError + # @return [Break] a new instance of Break + # + # source://parallel-1.22.1/lib/parallel.rb:17 + def initialize(value = T.unsafe(nil)); end + + # Returns the value of attribute value. + # + # source://parallel-1.22.1/lib/parallel.rb:15 + def value; end +end + +# source://parallel-1.22.1/lib/parallel.rb:11 +class Parallel::DeadWorker < ::StandardError; end + +# source://parallel-1.22.1/lib/parallel.rb:35 +class Parallel::ExceptionWrapper + # @return [ExceptionWrapper] a new instance of ExceptionWrapper + # + # source://parallel-1.22.1/lib/parallel.rb:38 + def initialize(exception); end + + # Returns the value of attribute exception. + # + # source://parallel-1.22.1/lib/parallel.rb:36 + def exception; end +end + +# source://parallel-1.22.1/lib/parallel.rb:101 +class Parallel::JobFactory + # @return [JobFactory] a new instance of JobFactory + # + # source://parallel-1.22.1/lib/parallel.rb:102 + def initialize(source, mutex); end + + # source://parallel-1.22.1/lib/parallel.rb:110 + def next; end + + # generate item that is sent to workers + # just index is faster + less likely to blow up with unserializable errors + # + # source://parallel-1.22.1/lib/parallel.rb:139 + def pack(item, index); end + + # source://parallel-1.22.1/lib/parallel.rb:129 + def size; end + + # unpack item that is sent to workers + # + # source://parallel-1.22.1/lib/parallel.rb:144 + def unpack(data); end + + private + + # @return [Boolean] + # + # source://parallel-1.22.1/lib/parallel.rb:150 + def producer?; end + + # source://parallel-1.22.1/lib/parallel.rb:154 + def queue_wrapper(array); end +end + +# source://parallel-1.22.1/lib/parallel.rb:23 +class Parallel::Kill < ::Parallel::Break; end + +# TODO: inline this method into parallel.rb and kill physical_processor_count in next major release +# +# source://parallel-1.22.1/lib/parallel/processor_count.rb:4 +module Parallel::ProcessorCount + # Number of physical processor cores on the current system. + # + # source://parallel-1.22.1/lib/parallel/processor_count.rb:12 + def physical_processor_count; end + + # Number of processors seen by the OS, used for process scheduling + # + # source://parallel-1.22.1/lib/parallel/processor_count.rb:6 + def processor_count; end +end + +# source://parallel-1.22.1/lib/parallel.rb:9 +Parallel::Stop = T.let(T.unsafe(nil), Object) + +# source://parallel-1.22.1/lib/parallel.rb:26 +class Parallel::UndumpableException < ::StandardError + # @return [UndumpableException] a new instance of UndumpableException + # + # source://parallel-1.22.1/lib/parallel.rb:29 + def initialize(original); end + + # Returns the value of attribute backtrace. + # + # source://parallel-1.22.1/lib/parallel.rb:27 + def backtrace; end +end + +# source://parallel-1.22.1/lib/parallel.rb:159 +class Parallel::UserInterruptHandler + class << self + # source://parallel-1.22.1/lib/parallel.rb:184 + def kill(thing); end + + # kill all these pids or threads if user presses Ctrl+c + # + # source://parallel-1.22.1/lib/parallel.rb:164 + def kill_on_ctrl_c(pids, options); end + + private + + # source://parallel-1.22.1/lib/parallel.rb:208 + def restore_interrupt(old, signal); end + + # source://parallel-1.22.1/lib/parallel.rb:193 + def trap_interrupt(signal); end + end +end + +# source://parallel-1.22.1/lib/parallel.rb:160 +Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol) + +# source://parallel-1.22.1/lib/parallel/version.rb:3 +Parallel::VERSION = T.let(T.unsafe(nil), String) + +# source://parallel-1.22.1/lib/parallel/version.rb:3 +Parallel::Version = T.let(T.unsafe(nil), String) + +# source://parallel-1.22.1/lib/parallel.rb:54 +class Parallel::Worker + # @return [Worker] a new instance of Worker + # + # source://parallel-1.22.1/lib/parallel.rb:58 + def initialize(read, write, pid); end + + # might be passed to started_processes and simultaneously closed by another thread + # when running in isolation mode, so we have to check if it is closed before closing + # + # source://parallel-1.22.1/lib/parallel.rb:71 + def close_pipes; end + + # Returns the value of attribute pid. + # + # source://parallel-1.22.1/lib/parallel.rb:55 + def pid; end + + # Returns the value of attribute read. + # + # source://parallel-1.22.1/lib/parallel.rb:55 + def read; end + + # source://parallel-1.22.1/lib/parallel.rb:64 + def stop; end + + # Returns the value of attribute thread. + # + # source://parallel-1.22.1/lib/parallel.rb:56 + def thread; end + + # Sets the attribute thread + # + # @param value the value to set the attribute thread to. + # + # source://parallel-1.22.1/lib/parallel.rb:56 + def thread=(_arg0); end + + # source://parallel-1.22.1/lib/parallel.rb:76 + def work(data); end + + # Returns the value of attribute write. + # + # source://parallel-1.22.1/lib/parallel.rb:55 + def write; end + + private + + # source://parallel-1.22.1/lib/parallel.rb:94 + def wait; end +end diff --git a/sorbet/rbi/gems/parser.rbi b/sorbet/rbi/gems/parser.rbi deleted file mode 100644 index 35b1527a..00000000 --- a/sorbet/rbi/gems/parser.rbi +++ /dev/null @@ -1,1440 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parser/all/parser.rbi -# -# parser-3.1.2.0 - -module Parser -end -module Parser::Messages - def self.compile(reason, arguments); end -end -module Parser::Deprecation - def warn_of_deprecation; end - def warned_of_deprecation=(arg0); end -end -module Parser::AST -end -class Parser::AST::Node < AST::Node - def assign_properties(properties); end - def loc; end - def location; end -end -class Parser::AST::Processor < AST::Processor - def on_alias(node); end - def on_and(node); end - def on_and_asgn(node); end - def on_arg(node); end - def on_arg_expr(node); end - def on_args(node); end - def on_argument(node); end - def on_array(node); end - def on_array_pattern(node); end - def on_array_pattern_with_tail(node); end - def on_back_ref(node); end - def on_begin(node); end - def on_block(node); end - def on_block_pass(node); end - def on_blockarg(node); end - def on_blockarg_expr(node); end - def on_break(node); end - def on_case(node); end - def on_case_match(node); end - def on_casgn(node); end - def on_class(node); end - def on_const(node); end - def on_const_pattern(node); end - def on_csend(node); end - def on_cvar(node); end - def on_cvasgn(node); end - def on_def(node); end - def on_defined?(node); end - def on_defs(node); end - def on_dstr(node); end - def on_dsym(node); end - def on_eflipflop(node); end - def on_empty_else(node); end - def on_ensure(node); end - def on_erange(node); end - def on_find_pattern(node); end - def on_for(node); end - def on_forward_arg(node); end - def on_gvar(node); end - def on_gvasgn(node); end - def on_hash(node); end - def on_hash_pattern(node); end - def on_if(node); end - def on_if_guard(node); end - def on_iflipflop(node); end - def on_in_match(node); end - def on_in_pattern(node); end - def on_index(node); end - def on_indexasgn(node); end - def on_irange(node); end - def on_ivar(node); end - def on_ivasgn(node); end - def on_kwarg(node); end - def on_kwargs(node); end - def on_kwbegin(node); end - def on_kwoptarg(node); end - def on_kwrestarg(node); end - def on_kwsplat(node); end - def on_lambda(node); end - def on_lvar(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_match_alt(node); end - def on_match_as(node); end - def on_match_current_line(node); end - def on_match_pattern(node); end - def on_match_pattern_p(node); end - def on_match_rest(node); end - def on_match_var(node); end - def on_match_with_lvasgn(node); end - def on_mlhs(node); end - def on_module(node); end - def on_next(node); end - def on_not(node); end - def on_nth_ref(node); end - def on_numblock(node); end - def on_op_asgn(node); end - def on_optarg(node); end - def on_or(node); end - def on_or_asgn(node); end - def on_pair(node); end - def on_pin(node); end - def on_postexe(node); end - def on_preexe(node); end - def on_procarg0(node); end - def on_redo(node); end - def on_regexp(node); end - def on_resbody(node); end - def on_rescue(node); end - def on_restarg(node); end - def on_restarg_expr(node); end - def on_retry(node); end - def on_return(node); end - def on_sclass(node); end - def on_send(node); end - def on_shadowarg(node); end - def on_splat(node); end - def on_super(node); end - def on_undef(node); end - def on_unless_guard(node); end - def on_until(node); end - def on_until_post(node); end - def on_var(node); end - def on_vasgn(node); end - def on_when(node); end - def on_while(node); end - def on_while_post(node); end - def on_xstr(node); end - def on_yield(node); end - def process_argument_node(node); end - def process_regular_node(node); end - def process_var_asgn_node(node); end - def process_variable_node(node); end -end -module Parser::Meta -end -module Parser::Source -end -class Parser::Source::Buffer - def bsearch(line_begins, position); end - def column_for_position(position); end - def decompose_position(position); end - def first_line; end - def freeze; end - def initialize(name, first_line = nil, source: nil); end - def inspect; end - def last_line; end - def line_begins; end - def line_for_position(position); end - def line_index_for_position(position); end - def line_range(lineno); end - def name; end - def raw_source=(input); end - def read; end - def self.recognize_encoding(string); end - def self.reencode_string(input); end - def slice(range); end - def source; end - def source=(input); end - def source_line(lineno); end - def source_lines; end - def source_range; end -end -class Parser::Source::Range - def <=>(other); end - def adjust(begin_pos: nil, end_pos: nil); end - def begin; end - def begin_pos; end - def column; end - def column_range; end - def contained?(other); end - def contains?(other); end - def crossing?(other); end - def disjoint?(other); end - def empty?; end - def end; end - def end_pos; end - def eql?(arg0); end - def first_line; end - def hash; end - def initialize(source_buffer, begin_pos, end_pos); end - def inspect; end - def intersect(other); end - def is?(*what); end - def join(other); end - def last_column; end - def last_line; end - def length; end - def line; end - def overlaps?(other); end - def resize(new_size); end - def size; end - def source; end - def source_buffer; end - def source_line; end - def to_a; end - def to_range; end - def to_s; end - def with(begin_pos: nil, end_pos: nil); end - include Comparable -end -class Parser::Source::Comment - def ==(other); end - def document?; end - def initialize(range); end - def inline?; end - def inspect; end - def loc; end - def location; end - def self.associate(ast, comments); end - def self.associate_by_identity(ast, comments); end - def self.associate_locations(ast, comments); end - def text; end - def type; end -end -class Parser::Source::Comment::Associator - def advance_comment; end - def advance_through_directives; end - def associate; end - def associate_and_advance_comment(node); end - def associate_by_identity; end - def associate_locations; end - def children_in_source_order(node); end - def current_comment_before?(node); end - def current_comment_before_end?(node); end - def current_comment_decorates?(node); end - def do_associate; end - def initialize(ast, comments); end - def process_leading_comments(node); end - def process_trailing_comments(node); end - def skip_directives; end - def skip_directives=(arg0); end - def visit(node); end -end -class Parser::Source::Rewriter - def active_clobber; end - def active_clobber=(value); end - def active_insertions; end - def active_insertions=(value); end - def active_queue; end - def adjacent?(range1, range2); end - def adjacent_insertion_mask(range); end - def adjacent_insertions?(range); end - def adjacent_position_mask(range); end - def adjacent_updates?(range); end - def append(action); end - def can_merge?(action, existing); end - def clobbered_insertion?(insertion); end - def clobbered_position_mask(range); end - def diagnostics; end - def in_transaction?; end - def initialize(source_buffer); end - def insert_after(range, content); end - def insert_after_multi(range, content); end - def insert_before(range, content); end - def insert_before_multi(range, content); end - def merge_actions!(action, existing); end - def merge_actions(action, existing); end - def merge_replacements(actions); end - def process; end - def raise_clobber_error(action, existing); end - def record_insertion(range); end - def record_replace(range); end - def remove(range); end - def replace(range, content); end - def replace_actions(old, updated); end - def replace_compatible_with_insertion?(replace, insertion); end - def source_buffer; end - def transaction; end - def wrap(range, before, after); end - extend Parser::Deprecation -end -class Parser::Source::Rewriter::Action - def <=>(other); end - def allow_multiple_insertions; end - def allow_multiple_insertions?; end - def initialize(range, replacement = nil, allow_multiple_insertions = nil, order = nil); end - def order; end - def range; end - def replacement; end - def to_s; end - include Comparable -end -class Parser::Source::TreeRewriter - def action_root; end - def action_summary; end - def as_nested_actions; end - def as_replacements; end - def check_policy_validity; end - def check_range_validity(range); end - def combine(range, attributes); end - def diagnostics; end - def empty?; end - def enforce_policy(event); end - def import!(foreign_rewriter, offset: nil); end - def in_transaction?; end - def initialize(source_buffer, crossing_deletions: nil, different_replacements: nil, swallowed_insertions: nil); end - def insert_after(range, content); end - def insert_after_multi(range, text); end - def insert_before(range, content); end - def insert_before_multi(range, text); end - def inspect; end - def merge!(with); end - def merge(with); end - def process; end - def remove(range); end - def replace(range, content); end - def source_buffer; end - def transaction; end - def trigger_policy(event, range: nil, conflict: nil, **arguments); end - def wrap(range, insert_before, insert_after); end - extend Parser::Deprecation -end -class Parser::Source::TreeRewriter::Action - def analyse_hierarchy(action); end - def bsearch_child_index(from = nil); end - def call_enforcer_for_merge(action); end - def check_fusible(action, *fusible); end - def children; end - def combine(action); end - def combine_children(more_children); end - def contract; end - def do_combine(action); end - def empty?; end - def fuse_deletions(action, fusible, other_sibblings); end - def initialize(range, enforcer, insert_before: nil, replacement: nil, insert_after: nil, children: nil); end - def insert_after; end - def insert_before; end - def insertion?; end - def merge(action); end - def moved(source_buffer, offset); end - def nested_actions; end - def ordered_replacements; end - def place_in_hierarchy(action); end - def range; end - def replacement; end - def swallow(children); end - def with(range: nil, enforcer: nil, children: nil, insert_before: nil, replacement: nil, insert_after: nil); end -end -class Parser::Source::Map - def ==(other); end - def column; end - def expression; end - def first_line; end - def initialize(expression); end - def initialize_copy(other); end - def last_column; end - def last_line; end - def line; end - def node; end - def node=(node); end - def to_hash; end - def update_expression(expression_l); end - def with(&block); end - def with_expression(expression_l); end -end -class Parser::Source::Map::Operator < Parser::Source::Map - def initialize(operator, expression); end - def operator; end -end -class Parser::Source::Map::Collection < Parser::Source::Map - def begin; end - def end; end - def initialize(begin_l, end_l, expression_l); end -end -class Parser::Source::Map::Constant < Parser::Source::Map - def double_colon; end - def initialize(double_colon, name, expression); end - def name; end - def operator; end - def update_operator(operator_l); end - def with_operator(operator_l); end -end -class Parser::Source::Map::Variable < Parser::Source::Map - def initialize(name_l, expression_l = nil); end - def name; end - def operator; end - def update_operator(operator_l); end - def with_operator(operator_l); end -end -class Parser::Source::Map::Keyword < Parser::Source::Map - def begin; end - def end; end - def initialize(keyword_l, begin_l, end_l, expression_l); end - def keyword; end -end -class Parser::Source::Map::Definition < Parser::Source::Map - def end; end - def initialize(keyword_l, operator_l, name_l, end_l); end - def keyword; end - def name; end - def operator; end -end -class Parser::Source::Map::MethodDefinition < Parser::Source::Map - def assignment; end - def end; end - def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end - def keyword; end - def name; end - def operator; end -end -class Parser::Source::Map::Send < Parser::Source::Map - def begin; end - def dot; end - def end; end - def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end - def operator; end - def selector; end - def update_operator(operator_l); end - def with_operator(operator_l); end -end -class Parser::Source::Map::Index < Parser::Source::Map - def begin; end - def end; end - def initialize(begin_l, end_l, expression_l); end - def operator; end - def update_operator(operator_l); end - def with_operator(operator_l); end -end -class Parser::Source::Map::Condition < Parser::Source::Map - def begin; end - def else; end - def end; end - def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end - def keyword; end -end -class Parser::Source::Map::Ternary < Parser::Source::Map - def colon; end - def initialize(question_l, colon_l, expression_l); end - def question; end -end -class Parser::Source::Map::For < Parser::Source::Map - def begin; end - def end; end - def in; end - def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end - def keyword; end -end -class Parser::Source::Map::RescueBody < Parser::Source::Map - def assoc; end - def begin; end - def initialize(keyword_l, assoc_l, begin_l, expression_l); end - def keyword; end -end -class Parser::Source::Map::Heredoc < Parser::Source::Map - def heredoc_body; end - def heredoc_end; end - def initialize(begin_l, body_l, end_l); end -end -class Parser::Source::Map::ObjcKwarg < Parser::Source::Map - def argument; end - def initialize(keyword_l, operator_l, argument_l, expression_l); end - def keyword; end - def operator; end -end -class Parser::SyntaxError < StandardError - def diagnostic; end - def initialize(diagnostic); end -end -class Parser::ClobberingError < RuntimeError -end -class Parser::Diagnostic - def arguments; end - def first_line_only(range); end - def highlights; end - def initialize(level, reason, arguments, location, highlights = nil); end - def last_line_only(range); end - def level; end - def location; end - def message; end - def reason; end - def render; end - def render_line(range, ellipsis = nil, range_end = nil); end -end -class Parser::Diagnostic::Engine - def all_errors_are_fatal; end - def all_errors_are_fatal=(arg0); end - def consumer; end - def consumer=(arg0); end - def ignore?(diagnostic); end - def ignore_warnings; end - def ignore_warnings=(arg0); end - def initialize(consumer = nil); end - def process(diagnostic); end - def raise?(diagnostic); end -end -class Parser::StaticEnvironment - def declare(name); end - def declare_anonymous_blockarg; end - def declare_forward_args; end - def declared?(name); end - def declared_anonymous_blockarg?; end - def declared_forward_args?; end - def empty?; end - def extend_dynamic; end - def extend_static; end - def initialize; end - def reset; end - def unextend; end -end -class Parser::Lexer - def advance; end - def arg_or_cmdarg(cmd_state); end - def cmdarg; end - def cmdarg=(arg0); end - def cmdarg_stack; end - def command_start; end - def command_start=(arg0); end - def comments; end - def comments=(arg0); end - def cond; end - def cond=(arg0); end - def cond_stack; end - def context; end - def context=(arg0); end - def dedent_level; end - def diagnostic(type, reason, arguments = nil, location = nil, highlights = nil); end - def diagnostics; end - def diagnostics=(arg0); end - def emit(type, value = nil, s = nil, e = nil); end - def emit_comment(s = nil, e = nil); end - def emit_do(do_block = nil); end - def emit_table(table, s = nil, e = nil); end - def encode_escape(ord); end - def encoding; end - def eof_codepoint?(point); end - def force_utf32; end - def force_utf32=(arg0); end - def initialize(version); end - def lambda_stack; end - def literal; end - def next_state_for_literal(literal); end - def paren_nest; end - def pop_cmdarg; end - def pop_cond; end - def pop_literal; end - def push_cmdarg; end - def push_cond; end - def push_literal(*args); end - def range(s = nil, e = nil); end - def reset(reset_state = nil); end - def self._lex_eof_trans; end - def self._lex_eof_trans=(arg0); end - def self._lex_from_state_actions; end - def self._lex_from_state_actions=(arg0); end - def self._lex_index_offsets; end - def self._lex_index_offsets=(arg0); end - def self._lex_indicies; end - def self._lex_indicies=(arg0); end - def self._lex_key_spans; end - def self._lex_key_spans=(arg0); end - def self._lex_to_state_actions; end - def self._lex_to_state_actions=(arg0); end - def self._lex_trans_actions; end - def self._lex_trans_actions=(arg0); end - def self._lex_trans_keys; end - def self._lex_trans_keys=(arg0); end - def self._lex_trans_targs; end - def self._lex_trans_targs=(arg0); end - def self.lex_en_expr_arg; end - def self.lex_en_expr_arg=(arg0); end - def self.lex_en_expr_beg; end - def self.lex_en_expr_beg=(arg0); end - def self.lex_en_expr_cmdarg; end - def self.lex_en_expr_cmdarg=(arg0); end - def self.lex_en_expr_dot; end - def self.lex_en_expr_dot=(arg0); end - def self.lex_en_expr_end; end - def self.lex_en_expr_end=(arg0); end - def self.lex_en_expr_endarg; end - def self.lex_en_expr_endarg=(arg0); end - def self.lex_en_expr_endfn; end - def self.lex_en_expr_endfn=(arg0); end - def self.lex_en_expr_fname; end - def self.lex_en_expr_fname=(arg0); end - def self.lex_en_expr_labelarg; end - def self.lex_en_expr_labelarg=(arg0); end - def self.lex_en_expr_mid; end - def self.lex_en_expr_mid=(arg0); end - def self.lex_en_expr_value; end - def self.lex_en_expr_value=(arg0); end - def self.lex_en_expr_variable; end - def self.lex_en_expr_variable=(arg0); end - def self.lex_en_interp_backslash_delimited; end - def self.lex_en_interp_backslash_delimited=(arg0); end - def self.lex_en_interp_backslash_delimited_words; end - def self.lex_en_interp_backslash_delimited_words=(arg0); end - def self.lex_en_interp_string; end - def self.lex_en_interp_string=(arg0); end - def self.lex_en_interp_words; end - def self.lex_en_interp_words=(arg0); end - def self.lex_en_leading_dot; end - def self.lex_en_leading_dot=(arg0); end - def self.lex_en_line_begin; end - def self.lex_en_line_begin=(arg0); end - def self.lex_en_line_comment; end - def self.lex_en_line_comment=(arg0); end - def self.lex_en_plain_backslash_delimited; end - def self.lex_en_plain_backslash_delimited=(arg0); end - def self.lex_en_plain_backslash_delimited_words; end - def self.lex_en_plain_backslash_delimited_words=(arg0); end - def self.lex_en_plain_string; end - def self.lex_en_plain_string=(arg0); end - def self.lex_en_plain_words; end - def self.lex_en_plain_words=(arg0); end - def self.lex_en_regexp_modifiers; end - def self.lex_en_regexp_modifiers=(arg0); end - def self.lex_error; end - def self.lex_error=(arg0); end - def self.lex_start; end - def self.lex_start=(arg0); end - def source_buffer; end - def source_buffer=(source_buffer); end - def stack_pop; end - def state; end - def state=(state); end - def static_env; end - def static_env=(arg0); end - def tok(s = nil, e = nil); end - def tokens; end - def tokens=(arg0); end - def version?(*versions); end -end -class Parser::Lexer::Literal - def backslash_delimited?; end - def clear_buffer; end - def coerce_encoding(string); end - def dedent_level; end - def delimiter?(delimiter); end - def emit(token, type, s, e); end - def emit_start_tok; end - def end_interp_brace_and_try_closing; end - def extend_content; end - def extend_space(ts, te); end - def extend_string(string, ts, te); end - def flush_string; end - def heredoc?; end - def heredoc_e; end - def infer_indent_level(line); end - def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = nil, dedent_body = nil, label_allowed = nil); end - def interpolate?; end - def munge_escape?(character); end - def nest_and_try_closing(delimiter, ts, te, lookahead = nil); end - def plain_heredoc?; end - def regexp?; end - def saved_herebody_s; end - def saved_herebody_s=(arg0); end - def squiggly_heredoc?; end - def start_interp_brace; end - def str_s; end - def supports_line_continuation_via_slash?; end - def type; end - def words?; end -end -class Parser::Lexer::StackState - def active?; end - def clear; end - def empty?; end - def initialize(name); end - def inspect; end - def lexpop; end - def pop; end - def push(bit); end - def to_s; end -end -class Parser::Lexer::Dedenter - def dedent(string); end - def initialize(dedent_level); end - def interrupt; end -end -class Parser::Builders::Default - def __ENCODING__(__ENCODING__t); end - def __FILE__(__FILE__t); end - def __LINE__(__LINE__t); end - def accessible(node); end - def alias(alias_t, to, from); end - def arg(name_t); end - def arg_expr(expr); end - def arg_name_collides?(this_name, that_name); end - def arg_prefix_map(op_t, name_t = nil); end - def args(begin_t, args, end_t, check_args = nil); end - def array(begin_t, elements, end_t); end - def array_pattern(lbrack_t, elements, rbrack_t); end - def assign(lhs, eql_t, rhs); end - def assignable(node); end - def associate(begin_t, pairs, end_t); end - def attr_asgn(receiver, dot_t, selector_t); end - def back_ref(token); end - def begin(begin_t, body, end_t); end - def begin_body(compound_stmt, rescue_bodies = nil, else_t = nil, else_ = nil, ensure_t = nil, ensure_ = nil); end - def begin_keyword(begin_t, body, end_t); end - def binary_op(receiver, operator_t, arg); end - def binary_op_map(left_e, op_t, right_e); end - def block(method_call, begin_t, args, body, end_t); end - def block_map(receiver_l, begin_t, end_t); end - def block_pass(amper_t, arg); end - def blockarg(amper_t, name_t); end - def blockarg_expr(amper_t, expr); end - def call_lambda(lambda_t); end - def call_method(receiver, dot_t, selector_t, lparen_t = nil, args = nil, rparen_t = nil); end - def call_type_for_dot(dot_t); end - def case(case_t, expr, when_bodies, else_t, else_body, end_t); end - def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end - def character(char_t); end - def check_assignment_to_numparam(name, loc); end - def check_condition(cond); end - def check_duplicate_arg(this_arg, map = nil); end - def check_duplicate_args(args, map = nil); end - def check_duplicate_pattern_key(name, loc); end - def check_duplicate_pattern_variable(name, loc); end - def check_lvar_name(name, loc); end - def check_reserved_for_numparam(name, loc); end - def collapse_string_parts?(parts); end - def collection_map(begin_t, parts, end_t); end - def complex(complex_t); end - def compstmt(statements); end - def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end - def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end - def condition_mod(if_true, if_false, cond_t, cond); end - def const(name_t); end - def const_fetch(scope, t_colon2, name_t); end - def const_global(t_colon3, name_t); end - def const_op_assignable(node); end - def const_pattern(const, ldelim_t, pattern, rdelim_t); end - def constant_map(scope, colon2_t, name_t); end - def cvar(token); end - def dedent_string(node, dedent_level); end - def def_class(class_t, name, lt_t, superclass, body, end_t); end - def def_endless_method(def_t, name_t, args, assignment_t, body); end - def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end - def def_method(def_t, name_t, args, body, end_t); end - def def_module(module_t, name, body, end_t); end - def def_sclass(class_t, lshft_t, expr, body, end_t); end - def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end - def definition_map(keyword_t, operator_t, name_t, end_t); end - def delimited_string_map(string_t); end - def diagnostic(type, reason, arguments, location, highlights = nil); end - def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end - def emit_file_line_as_literals; end - def emit_file_line_as_literals=(arg0); end - def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end - def expr_map(loc); end - def false(false_t); end - def find_pattern(lbrack_t, elements, rbrack_t); end - def float(float_t); end - def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end - def for_map(keyword_t, in_t, begin_t, end_t); end - def forward_arg(dots_t); end - def forward_only_args(begin_t, dots_t, end_t); end - def forwarded_args(dots_t); end - def guard_map(keyword_t, guard_body_e); end - def gvar(token); end - def hash_pattern(lbrace_t, kwargs, rbrace_t); end - def ident(token); end - def if_guard(if_t, if_body); end - def in_match(lhs, in_t, rhs); end - def in_pattern(in_t, pattern, guard, then_t, body); end - def index(receiver, lbrack_t, indexes, rbrack_t); end - def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end - def index_map(receiver_e, lbrack_t, rbrack_t); end - def initialize; end - def integer(integer_t); end - def ivar(token); end - def join_exprs(left_expr, right_expr); end - def keyword_cmd(type, keyword_t, lparen_t = nil, args = nil, rparen_t = nil); end - def keyword_map(keyword_t, begin_t, args, end_t); end - def keyword_mod_map(pre_e, keyword_t, post_e); end - def kwarg(name_t); end - def kwarg_map(name_t, value_e = nil); end - def kwargs?(node); end - def kwnilarg(dstar_t, nil_t); end - def kwoptarg(name_t, value); end - def kwrestarg(dstar_t, name_t = nil); end - def kwsplat(dstar_t, arg); end - def loc(token); end - def logical_op(type, lhs, op_t, rhs); end - def loop(type, keyword_t, cond, do_t, body, end_t); end - def loop_mod(type, body, keyword_t, cond); end - def match_alt(left, pipe_t, right); end - def match_as(value, assoc_t, as); end - def match_hash_var(name_t); end - def match_hash_var_from_str(begin_t, strings, end_t); end - def match_label(label_type, label); end - def match_nil_pattern(dstar_t, nil_t); end - def match_op(receiver, match_t, arg); end - def match_pair(label_type, label, value); end - def match_pattern(lhs, match_t, rhs); end - def match_pattern_p(lhs, match_t, rhs); end - def match_rest(star_t, name_t = nil); end - def match_var(name_t); end - def match_with_trailing_comma(match, comma_t); end - def module_definition_map(keyword_t, name_e, operator_t, end_t); end - def multi_assign(lhs, eql_t, rhs); end - def multi_lhs(begin_t, items, end_t); end - def n(type, children, source_map); end - def n0(type, source_map); end - def nil(nil_t); end - def not_op(not_t, begin_t = nil, receiver = nil, end_t = nil); end - def nth_ref(token); end - def numargs(max_numparam); end - def numeric(kind, token); end - def objc_kwarg(kwname_t, assoc_t, name_t); end - def objc_restarg(star_t, name = nil); end - def objc_varargs(pair, rest_of_varargs); end - def op_assign(lhs, op_t, rhs); end - def optarg(name_t, eql_t, value); end - def pair(key, assoc_t, value); end - def pair_keyword(key_t, value); end - def pair_keyword_map(key_t, value_e); end - def pair_label(key_t); end - def pair_list_18(list); end - def pair_quoted(begin_t, parts, end_t, value); end - def pair_quoted_map(begin_t, end_t, value_e); end - def parser; end - def parser=(arg0); end - def pin(pin_t, var); end - def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end - def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end - def prefix_string_map(symbol); end - def procarg0(arg); end - def range_exclusive(lhs, dot3_t, rhs); end - def range_inclusive(lhs, dot2_t, rhs); end - def range_map(start_e, op_t, end_e); end - def rational(rational_t); end - def regexp_compose(begin_t, parts, end_t, options); end - def regexp_map(begin_t, end_t, options_e); end - def regexp_options(regopt_t); end - def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end - def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end - def restarg(star_t, name_t = nil); end - def restarg_expr(star_t, expr = nil); end - def rewrite_hash_args_to_kwargs(args); end - def self(token); end - def self.emit_arg_inside_procarg0; end - def self.emit_arg_inside_procarg0=(arg0); end - def self.emit_encoding; end - def self.emit_encoding=(arg0); end - def self.emit_forward_arg; end - def self.emit_forward_arg=(arg0); end - def self.emit_index; end - def self.emit_index=(arg0); end - def self.emit_kwargs; end - def self.emit_kwargs=(arg0); end - def self.emit_lambda; end - def self.emit_lambda=(arg0); end - def self.emit_match_pattern; end - def self.emit_match_pattern=(arg0); end - def self.emit_procarg0; end - def self.emit_procarg0=(arg0); end - def self.modernize; end - def send_binary_op_map(lhs_e, selector_t, rhs_e); end - def send_index_map(receiver_e, lbrack_t, rbrack_t); end - def send_map(receiver_e, dot_t, selector_t, begin_t = nil, args = nil, end_t = nil); end - def send_unary_op_map(selector_t, arg_e); end - def shadowarg(name_t); end - def splat(star_t, arg = nil); end - def static_regexp(parts, options); end - def static_regexp_node(node); end - def static_string(nodes); end - def string(string_t); end - def string_compose(begin_t, parts, end_t); end - def string_internal(string_t); end - def string_map(begin_t, parts, end_t); end - def string_value(token); end - def symbol(symbol_t); end - def symbol_compose(begin_t, parts, end_t); end - def symbol_internal(symbol_t); end - def symbols_compose(begin_t, parts, end_t); end - def ternary(cond, question_t, if_true, colon_t, if_false); end - def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end - def token_map(token); end - def true(true_t); end - def unary_num(unary_t, numeric); end - def unary_op(op_t, receiver); end - def unary_op_map(op_t, arg_e = nil); end - def undef_method(undef_t, names); end - def unless_guard(unless_t, unless_body); end - def unquoted_map(token); end - def validate_definee(definee); end - def validate_no_forward_arg_after_restarg(args); end - def value(token); end - def var_send_map(variable_e); end - def variable_map(name_t); end - def when(when_t, patterns, then_t, body); end - def word(parts); end - def words_compose(begin_t, parts, end_t); end - def xstring_compose(begin_t, parts, end_t); end -end -class Parser::Context - def in_argdef; end - def in_argdef=(arg0); end - def in_block; end - def in_block=(arg0); end - def in_class; end - def in_class=(arg0); end - def in_def; end - def in_def=(arg0); end - def in_defined; end - def in_defined=(arg0); end - def in_dynamic_block?; end - def in_kwarg; end - def in_kwarg=(arg0); end - def in_lambda; end - def in_lambda=(arg0); end - def initialize; end - def reset; end -end -class Parser::MaxNumparamStack - def empty?; end - def has_numparams?; end - def has_ordinary_params!; end - def has_ordinary_params?; end - def initialize; end - def pop; end - def push(static:); end - def register(numparam); end - def set(value); end - def stack; end - def top; end -end -class Parser::CurrentArgStack - def empty?; end - def initialize; end - def pop; end - def push(value); end - def reset; end - def set(value); end - def stack; end - def top; end -end -class Parser::VariablesStack - def declare(name); end - def declared?(name); end - def empty?; end - def initialize; end - def pop; end - def push; end - def reset; end -end -class Parser::Base < Racc::Parser - def builder; end - def check_kwarg_name(name_t); end - def context; end - def current_arg_stack; end - def diagnostic(level, reason, arguments, location_t, highlights_ts = nil); end - def diagnostics; end - def initialize(builder = nil); end - def lexer; end - def max_numparam_stack; end - def next_token; end - def on_error(error_token_id, error_value, value_stack); end - def parse(source_buffer); end - def parse_with_comments(source_buffer); end - def pattern_hash_keys; end - def pattern_variables; end - def reset; end - def self.default_parser; end - def self.parse(string, file = nil, line = nil); end - def self.parse_file(filename); end - def self.parse_file_with_comments(filename); end - def self.parse_with_comments(string, file = nil, line = nil); end - def self.setup_source_buffer(file, line, string, encoding); end - def source_buffer; end - def static_env; end - def tokenize(source_buffer, recover = nil); end -end -class Parser::Rewriter < Parser::AST::Processor - def assignment?(node); end - def initialize(*arg0); end - def insert_after(range, content); end - def insert_before(range, content); end - def remove(range); end - def replace(range, content); end - def rewrite(source_buffer, ast); end - def wrap(range, before, after); end - extend Parser::Deprecation -end -class Parser::TreeRewriter < Parser::AST::Processor - def assignment?(node); end - def insert_after(range, content); end - def insert_before(range, content); end - def remove(range); end - def replace(range, content); end - def rewrite(source_buffer, ast, **policy); end - def wrap(range, before, after); end -end -module Parser::Builders -end -class Parser::Ruby24 < Parser::Base - def _reduce_10(val, _values, result); end - def _reduce_100(val, _values, result); end - def _reduce_101(val, _values, result); end - def _reduce_102(val, _values, result); end - def _reduce_103(val, _values, result); end - def _reduce_104(val, _values, result); end - def _reduce_105(val, _values, result); end - def _reduce_106(val, _values, result); end - def _reduce_107(val, _values, result); end - def _reduce_108(val, _values, result); end - def _reduce_11(val, _values, result); end - def _reduce_110(val, _values, result); end - def _reduce_111(val, _values, result); end - def _reduce_112(val, _values, result); end - def _reduce_118(val, _values, result); end - def _reduce_12(val, _values, result); end - def _reduce_122(val, _values, result); end - def _reduce_123(val, _values, result); end - def _reduce_124(val, _values, result); end - def _reduce_13(val, _values, result); end - def _reduce_14(val, _values, result); end - def _reduce_16(val, _values, result); end - def _reduce_17(val, _values, result); end - def _reduce_18(val, _values, result); end - def _reduce_19(val, _values, result); end - def _reduce_196(val, _values, result); end - def _reduce_197(val, _values, result); end - def _reduce_198(val, _values, result); end - def _reduce_199(val, _values, result); end - def _reduce_2(val, _values, result); end - def _reduce_20(val, _values, result); end - def _reduce_200(val, _values, result); end - def _reduce_201(val, _values, result); end - def _reduce_202(val, _values, result); end - def _reduce_203(val, _values, result); end - def _reduce_204(val, _values, result); end - def _reduce_205(val, _values, result); end - def _reduce_206(val, _values, result); end - def _reduce_207(val, _values, result); end - def _reduce_208(val, _values, result); end - def _reduce_209(val, _values, result); end - def _reduce_21(val, _values, result); end - def _reduce_210(val, _values, result); end - def _reduce_211(val, _values, result); end - def _reduce_212(val, _values, result); end - def _reduce_213(val, _values, result); end - def _reduce_214(val, _values, result); end - def _reduce_215(val, _values, result); end - def _reduce_216(val, _values, result); end - def _reduce_217(val, _values, result); end - def _reduce_218(val, _values, result); end - def _reduce_219(val, _values, result); end - def _reduce_22(val, _values, result); end - def _reduce_220(val, _values, result); end - def _reduce_221(val, _values, result); end - def _reduce_222(val, _values, result); end - def _reduce_223(val, _values, result); end - def _reduce_224(val, _values, result); end - def _reduce_225(val, _values, result); end - def _reduce_226(val, _values, result); end - def _reduce_227(val, _values, result); end - def _reduce_228(val, _values, result); end - def _reduce_229(val, _values, result); end - def _reduce_23(val, _values, result); end - def _reduce_230(val, _values, result); end - def _reduce_231(val, _values, result); end - def _reduce_232(val, _values, result); end - def _reduce_233(val, _values, result); end - def _reduce_234(val, _values, result); end - def _reduce_235(val, _values, result); end - def _reduce_236(val, _values, result); end - def _reduce_24(val, _values, result); end - def _reduce_241(val, _values, result); end - def _reduce_242(val, _values, result); end - def _reduce_244(val, _values, result); end - def _reduce_245(val, _values, result); end - def _reduce_246(val, _values, result); end - def _reduce_248(val, _values, result); end - def _reduce_25(val, _values, result); end - def _reduce_251(val, _values, result); end - def _reduce_252(val, _values, result); end - def _reduce_253(val, _values, result); end - def _reduce_254(val, _values, result); end - def _reduce_255(val, _values, result); end - def _reduce_256(val, _values, result); end - def _reduce_257(val, _values, result); end - def _reduce_258(val, _values, result); end - def _reduce_259(val, _values, result); end - def _reduce_26(val, _values, result); end - def _reduce_260(val, _values, result); end - def _reduce_261(val, _values, result); end - def _reduce_262(val, _values, result); end - def _reduce_263(val, _values, result); end - def _reduce_264(val, _values, result); end - def _reduce_265(val, _values, result); end - def _reduce_266(val, _values, result); end - def _reduce_267(val, _values, result); end - def _reduce_269(val, _values, result); end - def _reduce_27(val, _values, result); end - def _reduce_270(val, _values, result); end - def _reduce_271(val, _values, result); end - def _reduce_28(val, _values, result); end - def _reduce_282(val, _values, result); end - def _reduce_283(val, _values, result); end - def _reduce_284(val, _values, result); end - def _reduce_285(val, _values, result); end - def _reduce_286(val, _values, result); end - def _reduce_287(val, _values, result); end - def _reduce_288(val, _values, result); end - def _reduce_289(val, _values, result); end - def _reduce_290(val, _values, result); end - def _reduce_291(val, _values, result); end - def _reduce_292(val, _values, result); end - def _reduce_293(val, _values, result); end - def _reduce_294(val, _values, result); end - def _reduce_295(val, _values, result); end - def _reduce_296(val, _values, result); end - def _reduce_297(val, _values, result); end - def _reduce_298(val, _values, result); end - def _reduce_299(val, _values, result); end - def _reduce_3(val, _values, result); end - def _reduce_30(val, _values, result); end - def _reduce_300(val, _values, result); end - def _reduce_301(val, _values, result); end - def _reduce_303(val, _values, result); end - def _reduce_304(val, _values, result); end - def _reduce_305(val, _values, result); end - def _reduce_306(val, _values, result); end - def _reduce_307(val, _values, result); end - def _reduce_308(val, _values, result); end - def _reduce_309(val, _values, result); end - def _reduce_31(val, _values, result); end - def _reduce_310(val, _values, result); end - def _reduce_311(val, _values, result); end - def _reduce_312(val, _values, result); end - def _reduce_313(val, _values, result); end - def _reduce_314(val, _values, result); end - def _reduce_315(val, _values, result); end - def _reduce_316(val, _values, result); end - def _reduce_317(val, _values, result); end - def _reduce_318(val, _values, result); end - def _reduce_319(val, _values, result); end - def _reduce_32(val, _values, result); end - def _reduce_320(val, _values, result); end - def _reduce_321(val, _values, result); end - def _reduce_322(val, _values, result); end - def _reduce_323(val, _values, result); end - def _reduce_324(val, _values, result); end - def _reduce_325(val, _values, result); end - def _reduce_326(val, _values, result); end - def _reduce_327(val, _values, result); end - def _reduce_328(val, _values, result); end - def _reduce_329(val, _values, result); end - def _reduce_330(val, _values, result); end - def _reduce_331(val, _values, result); end - def _reduce_332(val, _values, result); end - def _reduce_333(val, _values, result); end - def _reduce_335(val, _values, result); end - def _reduce_336(val, _values, result); end - def _reduce_339(val, _values, result); end - def _reduce_34(val, _values, result); end - def _reduce_343(val, _values, result); end - def _reduce_345(val, _values, result); end - def _reduce_348(val, _values, result); end - def _reduce_349(val, _values, result); end - def _reduce_35(val, _values, result); end - def _reduce_350(val, _values, result); end - def _reduce_351(val, _values, result); end - def _reduce_353(val, _values, result); end - def _reduce_354(val, _values, result); end - def _reduce_355(val, _values, result); end - def _reduce_356(val, _values, result); end - def _reduce_357(val, _values, result); end - def _reduce_358(val, _values, result); end - def _reduce_359(val, _values, result); end - def _reduce_36(val, _values, result); end - def _reduce_360(val, _values, result); end - def _reduce_361(val, _values, result); end - def _reduce_362(val, _values, result); end - def _reduce_363(val, _values, result); end - def _reduce_364(val, _values, result); end - def _reduce_365(val, _values, result); end - def _reduce_366(val, _values, result); end - def _reduce_367(val, _values, result); end - def _reduce_368(val, _values, result); end - def _reduce_369(val, _values, result); end - def _reduce_37(val, _values, result); end - def _reduce_370(val, _values, result); end - def _reduce_371(val, _values, result); end - def _reduce_373(val, _values, result); end - def _reduce_374(val, _values, result); end - def _reduce_375(val, _values, result); end - def _reduce_376(val, _values, result); end - def _reduce_377(val, _values, result); end - def _reduce_378(val, _values, result); end - def _reduce_379(val, _values, result); end - def _reduce_38(val, _values, result); end - def _reduce_380(val, _values, result); end - def _reduce_382(val, _values, result); end - def _reduce_383(val, _values, result); end - def _reduce_384(val, _values, result); end - def _reduce_385(val, _values, result); end - def _reduce_386(val, _values, result); end - def _reduce_387(val, _values, result); end - def _reduce_388(val, _values, result); end - def _reduce_389(val, _values, result); end - def _reduce_39(val, _values, result); end - def _reduce_390(val, _values, result); end - def _reduce_391(val, _values, result); end - def _reduce_393(val, _values, result); end - def _reduce_394(val, _values, result); end - def _reduce_395(val, _values, result); end - def _reduce_396(val, _values, result); end - def _reduce_397(val, _values, result); end - def _reduce_398(val, _values, result); end - def _reduce_399(val, _values, result); end - def _reduce_4(val, _values, result); end - def _reduce_40(val, _values, result); end - def _reduce_400(val, _values, result); end - def _reduce_401(val, _values, result); end - def _reduce_402(val, _values, result); end - def _reduce_403(val, _values, result); end - def _reduce_404(val, _values, result); end - def _reduce_405(val, _values, result); end - def _reduce_406(val, _values, result); end - def _reduce_407(val, _values, result); end - def _reduce_408(val, _values, result); end - def _reduce_409(val, _values, result); end - def _reduce_41(val, _values, result); end - def _reduce_410(val, _values, result); end - def _reduce_411(val, _values, result); end - def _reduce_412(val, _values, result); end - def _reduce_413(val, _values, result); end - def _reduce_414(val, _values, result); end - def _reduce_415(val, _values, result); end - def _reduce_416(val, _values, result); end - def _reduce_417(val, _values, result); end - def _reduce_418(val, _values, result); end - def _reduce_419(val, _values, result); end - def _reduce_420(val, _values, result); end - def _reduce_421(val, _values, result); end - def _reduce_422(val, _values, result); end - def _reduce_423(val, _values, result); end - def _reduce_424(val, _values, result); end - def _reduce_425(val, _values, result); end - def _reduce_426(val, _values, result); end - def _reduce_427(val, _values, result); end - def _reduce_429(val, _values, result); end - def _reduce_43(val, _values, result); end - def _reduce_430(val, _values, result); end - def _reduce_431(val, _values, result); end - def _reduce_434(val, _values, result); end - def _reduce_436(val, _values, result); end - def _reduce_441(val, _values, result); end - def _reduce_442(val, _values, result); end - def _reduce_443(val, _values, result); end - def _reduce_444(val, _values, result); end - def _reduce_445(val, _values, result); end - def _reduce_446(val, _values, result); end - def _reduce_447(val, _values, result); end - def _reduce_448(val, _values, result); end - def _reduce_449(val, _values, result); end - def _reduce_450(val, _values, result); end - def _reduce_451(val, _values, result); end - def _reduce_452(val, _values, result); end - def _reduce_453(val, _values, result); end - def _reduce_454(val, _values, result); end - def _reduce_455(val, _values, result); end - def _reduce_456(val, _values, result); end - def _reduce_457(val, _values, result); end - def _reduce_458(val, _values, result); end - def _reduce_459(val, _values, result); end - def _reduce_46(val, _values, result); end - def _reduce_460(val, _values, result); end - def _reduce_461(val, _values, result); end - def _reduce_462(val, _values, result); end - def _reduce_463(val, _values, result); end - def _reduce_464(val, _values, result); end - def _reduce_465(val, _values, result); end - def _reduce_466(val, _values, result); end - def _reduce_467(val, _values, result); end - def _reduce_468(val, _values, result); end - def _reduce_469(val, _values, result); end - def _reduce_47(val, _values, result); end - def _reduce_470(val, _values, result); end - def _reduce_471(val, _values, result); end - def _reduce_472(val, _values, result); end - def _reduce_473(val, _values, result); end - def _reduce_474(val, _values, result); end - def _reduce_475(val, _values, result); end - def _reduce_477(val, _values, result); end - def _reduce_478(val, _values, result); end - def _reduce_479(val, _values, result); end - def _reduce_48(val, _values, result); end - def _reduce_480(val, _values, result); end - def _reduce_481(val, _values, result); end - def _reduce_482(val, _values, result); end - def _reduce_483(val, _values, result); end - def _reduce_484(val, _values, result); end - def _reduce_485(val, _values, result); end - def _reduce_486(val, _values, result); end - def _reduce_487(val, _values, result); end - def _reduce_488(val, _values, result); end - def _reduce_489(val, _values, result); end - def _reduce_49(val, _values, result); end - def _reduce_490(val, _values, result); end - def _reduce_491(val, _values, result); end - def _reduce_492(val, _values, result); end - def _reduce_493(val, _values, result); end - def _reduce_494(val, _values, result); end - def _reduce_495(val, _values, result); end - def _reduce_496(val, _values, result); end - def _reduce_497(val, _values, result); end - def _reduce_498(val, _values, result); end - def _reduce_499(val, _values, result); end - def _reduce_5(val, _values, result); end - def _reduce_500(val, _values, result); end - def _reduce_501(val, _values, result); end - def _reduce_502(val, _values, result); end - def _reduce_503(val, _values, result); end - def _reduce_504(val, _values, result); end - def _reduce_505(val, _values, result); end - def _reduce_506(val, _values, result); end - def _reduce_507(val, _values, result); end - def _reduce_508(val, _values, result); end - def _reduce_509(val, _values, result); end - def _reduce_510(val, _values, result); end - def _reduce_511(val, _values, result); end - def _reduce_512(val, _values, result); end - def _reduce_513(val, _values, result); end - def _reduce_514(val, _values, result); end - def _reduce_515(val, _values, result); end - def _reduce_516(val, _values, result); end - def _reduce_517(val, _values, result); end - def _reduce_518(val, _values, result); end - def _reduce_519(val, _values, result); end - def _reduce_520(val, _values, result); end - def _reduce_521(val, _values, result); end - def _reduce_522(val, _values, result); end - def _reduce_523(val, _values, result); end - def _reduce_524(val, _values, result); end - def _reduce_525(val, _values, result); end - def _reduce_526(val, _values, result); end - def _reduce_527(val, _values, result); end - def _reduce_528(val, _values, result); end - def _reduce_529(val, _values, result); end - def _reduce_530(val, _values, result); end - def _reduce_531(val, _values, result); end - def _reduce_532(val, _values, result); end - def _reduce_533(val, _values, result); end - def _reduce_535(val, _values, result); end - def _reduce_536(val, _values, result); end - def _reduce_537(val, _values, result); end - def _reduce_538(val, _values, result); end - def _reduce_539(val, _values, result); end - def _reduce_540(val, _values, result); end - def _reduce_541(val, _values, result); end - def _reduce_542(val, _values, result); end - def _reduce_543(val, _values, result); end - def _reduce_544(val, _values, result); end - def _reduce_545(val, _values, result); end - def _reduce_546(val, _values, result); end - def _reduce_547(val, _values, result); end - def _reduce_548(val, _values, result); end - def _reduce_549(val, _values, result); end - def _reduce_55(val, _values, result); end - def _reduce_552(val, _values, result); end - def _reduce_553(val, _values, result); end - def _reduce_554(val, _values, result); end - def _reduce_555(val, _values, result); end - def _reduce_556(val, _values, result); end - def _reduce_557(val, _values, result); end - def _reduce_558(val, _values, result); end - def _reduce_559(val, _values, result); end - def _reduce_56(val, _values, result); end - def _reduce_562(val, _values, result); end - def _reduce_563(val, _values, result); end - def _reduce_566(val, _values, result); end - def _reduce_567(val, _values, result); end - def _reduce_568(val, _values, result); end - def _reduce_57(val, _values, result); end - def _reduce_570(val, _values, result); end - def _reduce_571(val, _values, result); end - def _reduce_573(val, _values, result); end - def _reduce_574(val, _values, result); end - def _reduce_575(val, _values, result); end - def _reduce_576(val, _values, result); end - def _reduce_577(val, _values, result); end - def _reduce_578(val, _values, result); end - def _reduce_59(val, _values, result); end - def _reduce_591(val, _values, result); end - def _reduce_592(val, _values, result); end - def _reduce_597(val, _values, result); end - def _reduce_598(val, _values, result); end - def _reduce_6(val, _values, result); end - def _reduce_60(val, _values, result); end - def _reduce_602(val, _values, result); end - def _reduce_606(val, _values, result); end - def _reduce_61(val, _values, result); end - def _reduce_62(val, _values, result); end - def _reduce_63(val, _values, result); end - def _reduce_64(val, _values, result); end - def _reduce_65(val, _values, result); end - def _reduce_66(val, _values, result); end - def _reduce_67(val, _values, result); end - def _reduce_68(val, _values, result); end - def _reduce_69(val, _values, result); end - def _reduce_70(val, _values, result); end - def _reduce_71(val, _values, result); end - def _reduce_72(val, _values, result); end - def _reduce_73(val, _values, result); end - def _reduce_75(val, _values, result); end - def _reduce_76(val, _values, result); end - def _reduce_77(val, _values, result); end - def _reduce_78(val, _values, result); end - def _reduce_79(val, _values, result); end - def _reduce_8(val, _values, result); end - def _reduce_80(val, _values, result); end - def _reduce_81(val, _values, result); end - def _reduce_82(val, _values, result); end - def _reduce_83(val, _values, result); end - def _reduce_85(val, _values, result); end - def _reduce_86(val, _values, result); end - def _reduce_87(val, _values, result); end - def _reduce_88(val, _values, result); end - def _reduce_89(val, _values, result); end - def _reduce_9(val, _values, result); end - def _reduce_90(val, _values, result); end - def _reduce_91(val, _values, result); end - def _reduce_92(val, _values, result); end - def _reduce_93(val, _values, result); end - def _reduce_94(val, _values, result); end - def _reduce_95(val, _values, result); end - def _reduce_96(val, _values, result); end - def _reduce_97(val, _values, result); end - def _reduce_98(val, _values, result); end - def _reduce_99(val, _values, result); end - def _reduce_none(val, _values, result); end - def default_encoding; end - def local_pop; end - def local_push; end - def version; end -end diff --git a/sorbet/rbi/gems/parser@3.1.2.1.rbi b/sorbet/rbi/gems/parser@3.1.2.1.rbi new file mode 100644 index 00000000..3d9724d5 --- /dev/null +++ b/sorbet/rbi/gems/parser@3.1.2.1.rbi @@ -0,0 +1,8937 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `parser` gem. +# Please instead update this file by running `bin/tapioca gem parser`. + +# @api public +# +# source://parser-3.1.2.1/lib/parser.rb:19 +module Parser + class << self + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/current.rb:5 + def warn_syntax_deviation(feature, version); end + end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser.rb:24 +module Parser::AST; end + +# {Parser::AST::Node} contains information about a single AST node and its +# child nodes. It extends the basic [AST::Node](http://rdoc.info/gems/ast/AST/Node) +# class provided by gem [ast](http://rdoc.info/gems/ast). +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/ast/node.rb:17 +class Parser::AST::Node < ::AST::Node + # Assigns various properties to this AST node. Currently only the + # location can be set. + # + # @api public + # @option properties + # @param properties [Hash] + # + # source://parser-3.1.2.1/lib/parser/ast/node.rb:30 + def assign_properties(properties); end + + # Source map for this Node. + # + # @api public + # @return [Parser::Source::Map] + # + # source://parser-3.1.2.1/lib/parser/ast/node.rb:18 + def loc; end + + # Source map for this Node. + # + # @api public + # @return [Parser::Source::Map] + # + # source://parser-3.1.2.1/lib/parser/ast/node.rb:18 + def location; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/ast/processor.rb:9 +class Parser::AST::Processor < ::AST::Processor + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_alias(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_and(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_and_asgn(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_arg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_arg_expr(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_args(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:103 + def on_argument(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_array(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_array_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_array_pattern_with_tail(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_back_ref(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_begin(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_block(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_block_pass(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_blockarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_blockarg_expr(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_break(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_case(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_case_match(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:87 + def on_casgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_class(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:79 + def on_const(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_const_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:176 + def on_csend(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_cvar(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:56 + def on_cvasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:155 + def on_def(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_defined?(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:164 + def on_defs(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_dstr(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_dsym(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_eflipflop(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:283 + def on_empty_else(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_ensure(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_erange(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_find_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_for(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_forward_arg(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_gvar(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:56 + def on_gvasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_hash(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_hash_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_if(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_if_guard(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_iflipflop(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_in_match(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_in_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_index(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_indexasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_irange(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_ivar(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:56 + def on_ivasgn(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_kwarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_kwargs(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_kwbegin(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_kwoptarg(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_kwrestarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_kwsplat(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_lambda(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_lvar(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:56 + def on_lvasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_masgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_alt(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_as(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_current_line(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_pattern(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_pattern_p(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_rest(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_match_var(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_match_with_lvasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_mlhs(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_module(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_next(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_not(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:32 + def on_nth_ref(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:193 + def on_numblock(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:68 + def on_op_asgn(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_optarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_or(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_or_asgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_pair(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_pin(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_postexe(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_preexe(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:130 + def on_procarg0(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_redo(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_regexp(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_resbody(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_rescue(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_restarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_restarg_expr(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_retry(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_return(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_sclass(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:176 + def on_send(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:116 + def on_shadowarg(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_splat(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_super(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_undef(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_unless_guard(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_until(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_until_post(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:27 + def on_var(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:43 + def on_vasgn(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_when(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_while(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_while_post(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_xstr(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def on_yield(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:276 + def process_argument_node(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:10 + def process_regular_node(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:268 + def process_var_asgn_node(node); end + + # @api public + # @private + # + # source://parser-3.1.2.1/lib/parser/ast/processor.rb:260 + def process_variable_node(node); end +end + +# Base class for version-specific parsers. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/base.rb:29 +class Parser::Base < ::Racc::Parser + # @api public + # @param builder [Parser::Builders::Default] The AST builder to use. + # @return [Base] a new instance of Base + # + # source://parser-3.1.2.1/lib/parser/base.rb:126 + def initialize(builder = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:114 + def builder; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:117 + def context; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:119 + def current_arg_stack; end + + # @api public + # @return [Parser::Diagnostic::Engine] + # + # source://parser-3.1.2.1/lib/parser/base.rb:113 + def diagnostics; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:112 + def lexer; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:118 + def max_numparam_stack; end + + # Parses a source buffer and returns the AST, or `nil` in case of a non fatal error. + # + # @api public + # @param source_buffer [Parser::Source::Buffer] The source buffer to parse. + # @return [Parser::AST::Node, nil] + # + # source://parser-3.1.2.1/lib/parser/base.rb:186 + def parse(source_buffer); end + + # Parses a source buffer and returns the AST and the source code comments. + # + # @api public + # @return [Array] + # @see #parse + # @see Parser::Source::Comment#associate + # + # source://parser-3.1.2.1/lib/parser/base.rb:204 + def parse_with_comments(source_buffer); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:121 + def pattern_hash_keys; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:120 + def pattern_variables; end + + # Resets the state of the parser. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:167 + def reset; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:116 + def source_buffer; end + + # @api public + # @return [Parser::StaticEnvironment] + # + # source://parser-3.1.2.1/lib/parser/base.rb:115 + def static_env; end + + # Parses a source buffer and returns the AST, the source code comments, + # and the tokens emitted by the lexer. In case of a fatal error, a {SyntaxError} + # is raised, unless `recover` is true. In case of an error + # (non-fatal or recovered), `nil` is returned instead of the AST, and + # comments as well as tokens are only returned up to the location of + # the error. + # + # Currently, token stream format returned by #tokenize is not documented, + # but is considered part of a public API and only changed according + # to Semantic Versioning. + # + # However, note that the exact token composition of various constructs + # might vary. For example, a string `"foo"` is represented equally well + # by `:tSTRING_BEG " :tSTRING_CONTENT foo :tSTRING_END "` and + # `:tSTRING "foo"`; such details must not be relied upon. + # + # @api public + # @param source_buffer [Parser::Source::Buffer] + # @param recover [Boolean] If true, recover from syntax errors. False by default. + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/base.rb:233 + def tokenize(source_buffer, recover = T.unsafe(nil)); end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:257 + def check_kwarg_name(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:266 + def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:251 + def next_token; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:282 + def on_error(error_token_id, error_value, value_stack); end + + class << self + # @api public + # @return [Parser::Base] parser with the default options set. + # + # source://parser-3.1.2.1/lib/parser/base.rb:84 + def default_parser; end + + # Parses a string of Ruby code and returns the AST. If the source + # cannot be parsed, {SyntaxError} is raised and a diagnostic is + # printed to `stderr`. + # + # @api public + # @example + # Parser::Base.parse('puts "hello"') + # @param string [String] The block of code to parse. + # @param file [String] The name of the file the code originated from. + # @param line [Numeric] The initial line number. + # @return [Parser::AST::Node] + # + # source://parser-3.1.2.1/lib/parser/base.rb:30 + def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end + + # Parses Ruby source code by reading it from a file. If the source + # cannot be parsed, {SyntaxError} is raised and a diagnostic is + # printed to `stderr`. + # + # @api public + # @param filename [String] Path to the file to parse. + # @return [Parser::AST::Node] + # @see #parse + # + # source://parser-3.1.2.1/lib/parser/base.rb:64 + def parse_file(filename); end + + # Parses Ruby source code by reading it from a file and returns the AST and + # comments. If the source cannot be parsed, {SyntaxError} is raised and a + # diagnostic is printed to `stderr`. + # + # @api public + # @param filename [String] Path to the file to parse. + # @return [Array] + # @see #parse + # + # source://parser-3.1.2.1/lib/parser/base.rb:77 + def parse_file_with_comments(filename); end + + # Parses a string of Ruby code and returns the AST and comments. If the + # source cannot be parsed, {SyntaxError} is raised and a diagnostic is + # printed to `stderr`. + # + # @api public + # @example + # Parser::Base.parse_with_comments('puts "hello"') + # @param string [String] The block of code to parse. + # @param file [String] The name of the file the code originated from. + # @param line [Numeric] The initial line number. + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/base.rb:49 + def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/base.rb:97 + def setup_source_buffer(file, line, string, encoding); end + end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser.rb:72 +module Parser::Builders; end + +# Default AST builder. Uses {AST::Node}s. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/builders/default.rb:8 +class Parser::Builders::Default + # Initializes attributes: + # + # * `emit_file_line_as_literals`: `true` + # + # @api public + # @return [Default] a new instance of Default + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:243 + def initialize; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:696 + def __ENCODING__(__ENCODING__t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:348 + def __FILE__(__FILE__t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:312 + def __LINE__(__LINE__t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:622 + def accessible(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:871 + def alias(alias_t, to, from); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:910 + def arg(name_t); end + + # Ruby 1.8 block arguments + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1000 + def arg_expr(expr); end + + # Formal arguments + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:880 + def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end + + # Arrays + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:440 + def array(begin_t, elements, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1575 + def array_pattern(lbrack_t, elements, rbrack_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:760 + def assign(lhs, eql_t, rhs); end + + # Assignment + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:705 + def assignable(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:540 + def associate(begin_t, pairs, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1156 + def attr_asgn(receiver, dot_t, selector_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:612 + def back_ref(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1420 + def begin(begin_t, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1362 + def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1438 + def begin_keyword(begin_t, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1190 + def binary_op(receiver, operator_t, arg); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1107 + def block(method_call, begin_t, args, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1142 + def block_pass(amper_t, arg); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:975 + def blockarg(amper_t, name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1020 + def blockarg_expr(amper_t, expr); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1098 + def call_lambda(lambda_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1081 + def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end + + # Method calls + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1061 + def call_type_for_dot(dot_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1295 + def case(case_t, expr, when_bodies, else_t, else_body, end_t); end + + # PATTERN MATCHING + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1458 + def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:343 + def character(char_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:284 + def complex(complex_t); end + + # Expression grouping + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1408 + def compstmt(statements); end + + # Conditionals + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1271 + def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1277 + def condition_mod(if_true, if_false, cond_t, cond); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:679 + def const(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:691 + def const_fetch(scope, t_colon2, name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:684 + def const_global(t_colon3, name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:756 + def const_op_assignable(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1605 + def const_pattern(const, ldelim_t, pattern, rdelim_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:607 + def cvar(token); end + + # Indented (interpolated, noninterpolated, executable) strings + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:388 + def dedent_string(node, dedent_level); end + + # Class and module definition + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:807 + def def_class(class_t, name, lt_t, superclass, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:838 + def def_endless_method(def_t, name_t, args, assignment_t, body); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:856 + def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end + + # Method (un)definition + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:830 + def def_method(def_t, name_t, args, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:820 + def def_module(module_t, name, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:814 + def def_sclass(class_t, lshft_t, expr, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:846 + def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end + + # If set to true (the default), `__FILE__` and `__LINE__` are transformed to + # literal nodes. For example, `s(:str, "lib/foo.rb")` and `s(:int, 10)`. + # + # If set to false, `__FILE__` and `__LINE__` are emitted as-is, + # i.e. as `s(:__FILE__)` and `s(:__LINE__)` nodes. + # + # Source maps are identical in both cases. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:237 + def emit_file_line_as_literals; end + + # If set to true (the default), `__FILE__` and `__LINE__` are transformed to + # literal nodes. For example, `s(:str, "lib/foo.rb")` and `s(:int, 10)`. + # + # If set to false, `__FILE__` and `__LINE__` are emitted as-is, + # i.e. as `s(:__FILE__)` and `s(:__LINE__)` nodes. + # + # Source maps are identical in both cases. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:237 + def emit_file_line_as_literals=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:265 + def false(false_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1596 + def find_pattern(lbrack_t, elements, rbrack_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:276 + def float(float_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1316 + def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:906 + def forward_arg(dots_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:896 + def forward_only_args(begin_t, dots_t, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1077 + def forwarded_args(dots_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:602 + def gvar(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1569 + def hash_pattern(lbrace_t, kwargs, rbrace_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:592 + def ident(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1485 + def if_guard(if_t, if_body); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1464 + def in_match(lhs, in_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1479 + def in_pattern(in_t, pattern, guard, then_t, body); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1165 + def index(receiver, lbrack_t, indexes, rbrack_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1179 + def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end + + # Numerics + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:272 + def integer(integer_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:597 + def ivar(token); end + + # Keywords + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1324 + def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:937 + def kwarg(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:963 + def kwnilarg(dstar_t, nil_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:944 + def kwoptarg(name_t, value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:951 + def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:535 + def kwsplat(dstar_t, arg); end + + # Logical operations: and, or + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1264 + def logical_op(type, lhs, op_t, rhs); end + + # Loops + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1302 + def loop(type, keyword_t, cond, do_t, body, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1307 + def loop_mod(type, body, keyword_t, cond); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1619 + def match_alt(left, pipe_t, right); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1626 + def match_as(value, assoc_t, as); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1505 + def match_hash_var(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1519 + def match_hash_var_from_str(begin_t, strings, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1657 + def match_label(label_type, label); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1633 + def match_nil_pattern(dstar_t, nil_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1212 + def match_op(receiver, match_t, arg); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1638 + def match_pair(label_type, label, value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1469 + def match_pattern(lhs, match_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1474 + def match_pattern_p(lhs, match_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1558 + def match_rest(star_t, name_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1493 + def match_var(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1601 + def match_with_trailing_comma(match, comma_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:798 + def multi_assign(lhs, eql_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:793 + def multi_lhs(begin_t, items, end_t); end + + # Singletons + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:255 + def nil(nil_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1240 + def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:617 + def nth_ref(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:892 + def numargs(max_numparam); end + + # MacRuby Objective-C arguments + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1031 + def objc_kwarg(kwname_t, assoc_t, name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1045 + def objc_restarg(star_t, name = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1147 + def objc_varargs(pair, rest_of_varargs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:767 + def op_assign(lhs, op_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:917 + def optarg(name_t, eql_t, value); end + + # Hashes + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:488 + def pair(key, assoc_t, value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:505 + def pair_keyword(key_t, value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:521 + def pair_label(key_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:493 + def pair_list_18(list); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:513 + def pair_quoted(begin_t, parts, end_t, value); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:225 + def parser; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:225 + def parser=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1614 + def pin(pin_t, var); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1347 + def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end + + # BEGIN, END + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1342 + def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:985 + def procarg0(arg); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:578 + def range_exclusive(lhs, dot3_t, rhs); end + + # Ranges + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:573 + def range_inclusive(lhs, dot2_t, rhs); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:280 + def rational(rational_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:426 + def regexp_compose(begin_t, parts, end_t, options); end + + # Regular expressions + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:417 + def regexp_options(regopt_t); end + + # Exception handling + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1354 + def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:926 + def restarg(star_t, name_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1009 + def restarg_expr(star_t, expr = T.unsafe(nil)); end + + # Access + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:587 + def self(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:968 + def shadowarg(name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:445 + def splat(star_t, arg = T.unsafe(nil)); end + + # Strings + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:319 + def string(string_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:329 + def string_compose(begin_t, parts, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:324 + def string_internal(string_t); end + + # Symbols + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:355 + def symbol(symbol_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:365 + def symbol_compose(begin_t, parts, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:360 + def symbol_internal(symbol_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:469 + def symbols_compose(begin_t, parts, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1282 + def ternary(cond, question_t, if_true, colon_t, if_false); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:260 + def true(true_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:294 + def unary_num(unary_t, numeric); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1228 + def unary_op(op_t, receiver); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:866 + def undef_method(undef_t, names); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1489 + def unless_guard(unless_t, unless_body); end + + # Case matching + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1289 + def when(when_t, patterns, then_t, body); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:455 + def word(parts); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:464 + def words_compose(begin_t, parts, end_t); end + + # Executable strings + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:381 + def xstring_compose(begin_t, parts, end_t); end + + private + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1796 + def arg_name_collides?(this_name, that_name); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1992 + def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1966 + def binary_op_map(left_e, op_t, right_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2094 + def block_map(receiver_l, begin_t, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1771 + def check_assignment_to_numparam(name, loc); end + + # VERIFICATION + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1673 + def check_condition(cond); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1742 + def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1717 + def check_duplicate_args(args, map = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1829 + def check_duplicate_pattern_key(name, loc); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1819 + def check_duplicate_pattern_variable(name, loc); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1811 + def check_lvar_name(name, loc); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1786 + def check_reserved_for_numparam(name, loc); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2251 + def collapse_string_parts?(parts); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1917 + def collection_map(begin_t, parts, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2121 + def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1952 + def constant_map(scope, colon2_t, name_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2025 + def definition_map(keyword_t, operator_t, name_t, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1858 + def delimited_string_map(string_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2273 + def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2165 + def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2031 + def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1913 + def expr_map(loc); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2146 + def for_map(keyword_t, in_t, begin_t, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2193 + def guard_map(keyword_t, guard_body_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2083 + def index_map(receiver_e, lbrack_t, rbrack_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1849 + def join_exprs(left_expr, right_expr); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2099 + def keyword_map(keyword_t, begin_t, args, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2116 + def keyword_mod_map(pre_e, keyword_t, post_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2002 + def kwarg_map(name_t, value_e = T.unsafe(nil)); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2304 + def kwargs?(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2268 + def loc(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2015 + def module_definition_map(keyword_t, name_e, operator_t, end_t); end + + # SOURCE MAPS + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1841 + def n(type, children, source_map); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1845 + def n0(type, source_map); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:288 + def numeric(kind, token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1883 + def pair_keyword_map(key_t, value_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1898 + def pair_quoted_map(begin_t, end_t, value_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1869 + def prefix_string_map(symbol); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1980 + def range_map(start_e, op_t, end_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1947 + def regexp_map(begin_t, end_t, options_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2152 + def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2294 + def rewrite_hash_args_to_kwargs(args); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2065 + def send_binary_op_map(lhs_e, selector_t, rhs_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2088 + def send_index_map(receiver_e, lbrack_t, rbrack_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2039 + def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2071 + def send_unary_op_map(selector_t, arg_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2224 + def static_regexp(parts, options); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2244 + def static_regexp_node(node); end + + # Extract a static string from e.g. a regular expression, + # honoring the fact that MRI expands interpolations like #{""} + # at parse time. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2207 + def static_string(nodes); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1933 + def string_map(begin_t, parts, end_t); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2260 + def string_value(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2141 + def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1854 + def token_map(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1970 + def unary_op_map(op_t, arg_e = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1878 + def unquoted_map(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2282 + def validate_definee(definee); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1756 + def validate_no_forward_arg_after_restarg(args); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2256 + def value(token); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:2059 + def var_send_map(variable_e); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:1962 + def variable_map(name_t); end + + class << self + # AST compatibility attribute; causes a single non-mlhs + # block argument to be wrapped in s(:procarg0). + # + # If set to false (the default), block arguments `|a|` are emitted as + # `s(:args, s(:procarg0, :a))` + # + # If set to true, block arguments `|a|` are emitted as + # `s(:args, s(:procarg0, s(:arg, :a))` + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:97 + def emit_arg_inside_procarg0; end + + # AST compatibility attribute; causes a single non-mlhs + # block argument to be wrapped in s(:procarg0). + # + # If set to false (the default), block arguments `|a|` are emitted as + # `s(:args, s(:procarg0, :a))` + # + # If set to true, block arguments `|a|` are emitted as + # `s(:args, s(:procarg0, s(:arg, :a))` + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:97 + def emit_arg_inside_procarg0=(_arg0); end + + # AST compatibility attribute; locations of `__ENCODING__` are not the same + # as locations of `Encoding::UTF_8` causing problems during rewriting, + # all new code should set this attribute to true. + # + # If set to false (the default), `__ENCODING__` is emitted as + # ` s(:const, s(:const, nil, :Encoding), :UTF_8)`. + # + # If set to true, `__ENCODING__` is emitted as + # `s(:__ENCODING__)`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:58 + def emit_encoding; end + + # AST compatibility attribute; locations of `__ENCODING__` are not the same + # as locations of `Encoding::UTF_8` causing problems during rewriting, + # all new code should set this attribute to true. + # + # If set to false (the default), `__ENCODING__` is emitted as + # ` s(:const, s(:const, nil, :Encoding), :UTF_8)`. + # + # If set to true, `__ENCODING__` is emitted as + # `s(:__ENCODING__)`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:58 + def emit_encoding=(_arg0); end + + # AST compatibility attribute; arguments forwarding initially + # didn't have support for leading arguments + # (i.e. `def m(a, ...); end` was a syntax error). However, Ruby 3.0 + # added support for any number of arguments in front of the `...`. + # + # If set to false (the default): + # 1. `def m(...) end` is emitted as + # s(:def, :m, s(:forward_args), nil) + # 2. `def m(a, b, ...) end` is emitted as + # s(:def, :m, + # s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg))) + # + # If set to true it uses a single format: + # 1. `def m(...) end` is emitted as + # s(:def, :m, s(:args, s(:forward_arg))) + # 2. `def m(a, b, ...) end` is emitted as + # s(:def, :m, s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg))) + # + # It does't matter that much on 2.7 (because there can't be any leading arguments), + # but on 3.0 it should be better enabled to use a single AST format. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:126 + def emit_forward_arg; end + + # AST compatibility attribute; arguments forwarding initially + # didn't have support for leading arguments + # (i.e. `def m(a, ...); end` was a syntax error). However, Ruby 3.0 + # added support for any number of arguments in front of the `...`. + # + # If set to false (the default): + # 1. `def m(...) end` is emitted as + # s(:def, :m, s(:forward_args), nil) + # 2. `def m(a, b, ...) end` is emitted as + # s(:def, :m, + # s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg))) + # + # If set to true it uses a single format: + # 1. `def m(...) end` is emitted as + # s(:def, :m, s(:args, s(:forward_arg))) + # 2. `def m(a, b, ...) end` is emitted as + # s(:def, :m, s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg))) + # + # It does't matter that much on 2.7 (because there can't be any leading arguments), + # but on 3.0 it should be better enabled to use a single AST format. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:126 + def emit_forward_arg=(_arg0); end + + # AST compatibility attribute; indexed assignment, `x[] = 1`, is not + # semantically equivalent to calling the method directly, `x.[]=(1)`. + # Specifically, in the former case, the expression's value is always 1, + # and in the latter case, the expression's value is the return value + # of the `[]=` method. + # + # If set to false (the default), `self[1]` is emitted as + # `s(:send, s(:self), :[], s(:int, 1))`, and `self[1] = 2` is + # emitted as `s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))`. + # + # If set to true, `self[1]` is emitted as + # `s(:index, s(:self), s(:int, 1))`, and `self[1] = 2` is + # emitted as `s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:80 + def emit_index; end + + # AST compatibility attribute; indexed assignment, `x[] = 1`, is not + # semantically equivalent to calling the method directly, `x.[]=(1)`. + # Specifically, in the former case, the expression's value is always 1, + # and in the latter case, the expression's value is the return value + # of the `[]=` method. + # + # If set to false (the default), `self[1]` is emitted as + # `s(:send, s(:self), :[], s(:int, 1))`, and `self[1] = 2` is + # emitted as `s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))`. + # + # If set to true, `self[1]` is emitted as + # `s(:index, s(:self), s(:int, 1))`, and `self[1] = 2` is + # emitted as `s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:80 + def emit_index=(_arg0); end + + # AST compatibility attribute; Starting from Ruby 2.7 keyword arguments + # of method calls that are passed explicitly as a hash (i.e. with curly braces) + # are treated as positional arguments and Ruby 2.7 emits a warning on such method + # call. Ruby 3.0 given an ArgumentError. + # + # If set to false (the default) the last hash argument is emitted as `hash`: + # + # ``` + # (send nil :foo + # (hash + # (pair + # (sym :bar) + # (int 42)))) + # ``` + # + # If set to true it is emitted as `kwargs`: + # + # ``` + # (send nil :foo + # (kwargs + # (pair + # (sym :bar) + # (int 42)))) + # ``` + # + # Note that `kwargs` node is just a replacement for `hash` argument, + # so if there's are multiple arguments (or a `kwsplat`) all of them + # are wrapped into `kwargs` instead of `hash`: + # + # ``` + # (send nil :foo + # (kwargs + # (pair + # (sym :a) + # (int 42)) + # (kwsplat + # (send nil :b)) + # (pair + # (sym :c) + # (int 10)))) + # ``` + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:174 + def emit_kwargs; end + + # AST compatibility attribute; Starting from Ruby 2.7 keyword arguments + # of method calls that are passed explicitly as a hash (i.e. with curly braces) + # are treated as positional arguments and Ruby 2.7 emits a warning on such method + # call. Ruby 3.0 given an ArgumentError. + # + # If set to false (the default) the last hash argument is emitted as `hash`: + # + # ``` + # (send nil :foo + # (hash + # (pair + # (sym :bar) + # (int 42)))) + # ``` + # + # If set to true it is emitted as `kwargs`: + # + # ``` + # (send nil :foo + # (kwargs + # (pair + # (sym :bar) + # (int 42)))) + # ``` + # + # Note that `kwargs` node is just a replacement for `hash` argument, + # so if there's are multiple arguments (or a `kwsplat`) all of them + # are wrapped into `kwargs` instead of `hash`: + # + # ``` + # (send nil :foo + # (kwargs + # (pair + # (sym :a) + # (int 42)) + # (kwsplat + # (send nil :b)) + # (pair + # (sym :c) + # (int 10)))) + # ``` + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:174 + def emit_kwargs=(_arg0); end + + # AST compatibility attribute; since `-> {}` is not semantically + # equivalent to `lambda {}`, all new code should set this attribute + # to true. + # + # If set to false (the default), `-> {}` is emitted as + # `s(:block, s(:send, nil, :lambda), s(:args), nil)`. + # + # If set to true, `-> {}` is emitted as + # `s(:block, s(:lambda), s(:args), nil)`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:22 + def emit_lambda; end + + # AST compatibility attribute; since `-> {}` is not semantically + # equivalent to `lambda {}`, all new code should set this attribute + # to true. + # + # If set to false (the default), `-> {}` is emitted as + # `s(:block, s(:send, nil, :lambda), s(:args), nil)`. + # + # If set to true, `-> {}` is emitted as + # `s(:block, s(:lambda), s(:args), nil)`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:22 + def emit_lambda=(_arg0); end + + # AST compatibility attribute; Starting from 3.0 Ruby returns + # true/false from single-line pattern matching with `in` keyword. + # + # Before 3.0 there was an exception if given value doesn't match pattern. + # + # NOTE: This attribute affects only Ruby 2.7 grammar. + # 3.0 grammar always emits `match_pattern`/`match_pattern_p` + # + # If compatibility attribute set to false `foo in bar` is emitted as `in_match`: + # + # ``` + # (in-match + # (send nil :foo) + # (match-var :bar)) + # ``` + # + # If set to true it's emitted as `match_pattern_p`: + # ``` + # (match-pattern-p + # (send nil :foo) + # (match-var :bar)) + # ``` + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:203 + def emit_match_pattern; end + + # AST compatibility attribute; Starting from 3.0 Ruby returns + # true/false from single-line pattern matching with `in` keyword. + # + # Before 3.0 there was an exception if given value doesn't match pattern. + # + # NOTE: This attribute affects only Ruby 2.7 grammar. + # 3.0 grammar always emits `match_pattern`/`match_pattern_p` + # + # If compatibility attribute set to false `foo in bar` is emitted as `in_match`: + # + # ``` + # (in-match + # (send nil :foo) + # (match-var :bar)) + # ``` + # + # If set to true it's emitted as `match_pattern_p`: + # ``` + # (match-pattern-p + # (send nil :foo) + # (match-var :bar)) + # ``` + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:203 + def emit_match_pattern=(_arg0); end + + # AST compatibility attribute; block arguments of `m { |a| }` are + # not semantically equivalent to block arguments of `m { |a,| }` or `m { |a, b| }`, + # all new code should set this attribute to true. + # + # If set to false (the default), arguments of `m { |a| }` are emitted as + # `s(:args, s(:arg, :a))`. + # + # If set to true, arguments of `m { |a| }` are emitted as + # `s(:args, s(:procarg0, :a)). + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:40 + def emit_procarg0; end + + # AST compatibility attribute; block arguments of `m { |a| }` are + # not semantically equivalent to block arguments of `m { |a,| }` or `m { |a, b| }`, + # all new code should set this attribute to true. + # + # If set to false (the default), arguments of `m { |a| }` are emitted as + # `s(:args, s(:arg, :a))`. + # + # If set to true, arguments of `m { |a| }` are emitted as + # `s(:args, s(:procarg0, :a)). + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:40 + def emit_procarg0=(_arg0); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/builders/default.rb:211 + def modernize; end + end +end + +# {Parser::ClobberingError} is raised when {Parser::Source::Rewriter} +# detects a clobbering rewrite action. This class inherits {RuntimeError} +# rather than {StandardError} for backward compatibility. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/clobbering_error.rb:11 +class Parser::ClobberingError < ::RuntimeError; end + +# Context of parsing that is represented by a stack of scopes. +# +# Supported states: +# + :class - in the class body (class A; end) +# + :module - in the module body (module M; end) +# + :sclass - in the singleton class body (class << obj; end) +# + :def - in the method body (def m; end) +# + :defs - in the singleton method body (def self.m; end) +# + :def_open_args - in the arglist of the method definition +# keep in mind that it's set **only** after reducing the first argument, +# if you need to handle the first argument check `lex_state == expr_fname` +# + :block - in the block body (tap {}) +# + :lambda - in the lambda body (-> {}) +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/context.rb:18 +class Parser::Context + # @api public + # @return [Context] a new instance of Context + # + # source://parser-3.1.2.1/lib/parser/context.rb:29 + def initialize; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_argdef; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_argdef=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_block; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_block=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_class; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_class=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_def; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_def=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_defined; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_defined=(_arg0); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/context.rb:45 + def in_dynamic_block?; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_kwarg; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_kwarg=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_lambda; end + + # source://parser-3.1.2.1/lib/parser/context.rb:43 + def in_lambda=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/context.rb:33 + def reset; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/context.rb:19 +Parser::Context::FLAGS = T.let(T.unsafe(nil), Array) + +# Stack that holds names of current arguments, +# i.e. while parsing +# def m1(a = (def m2(b = def m3(c = 1); end); end)); end +# ^ +# stack is [:a, :b, :c] +# +# Emulates `p->cur_arg` in MRI's parse.y +# +# @api private +# +# source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:14 +class Parser::CurrentArgStack + # @api private + # @return [CurrentArgStack] a new instance of CurrentArgStack + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:17 + def initialize; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:22 + def empty?; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:34 + def pop; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:26 + def push(value); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:38 + def reset; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:30 + def set(value); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:15 + def stack; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/current_arg_stack.rb:42 + def top; end +end + +# source://parser-3.1.2.1/lib/parser/current.rb:84 +Parser::CurrentRuby = Parser::Ruby27 + +# @api private +# +# source://parser-3.1.2.1/lib/parser/deprecation.rb:7 +module Parser::Deprecation + # @api private + # + # source://parser-3.1.2.1/lib/parser/deprecation.rb:9 + def warn_of_deprecation; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/deprecation.rb:8 + def warned_of_deprecation=(_arg0); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/diagnostic.rb:31 +class Parser::Diagnostic + # @api public + # @param level [Symbol] + # @param reason [Symbol] + # @param arguments [Hash] + # @param location [Parser::Source::Range] + # @param highlights [Array] + # @return [Diagnostic] a new instance of Diagnostic + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:49 + def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end + + # @api public + # @return [Symbol] extended arguments that describe the error + # @see Parser::MESSAGES + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:39 + def arguments; end + + # Supplementary error-related source ranges. + # + # @api public + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:40 + def highlights; end + + # @api public + # @return [Symbol] diagnostic level + # @see LEVELS + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:39 + def level; end + + # Main error-related source range. + # + # @api public + # @return [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:40 + def location; end + + # @api public + # @return [String] the rendered message. + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:69 + def message; end + + # @api public + # @return [Symbol] reason for error + # @see Parser::MESSAGES + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:39 + def reason; end + + # Renders the diagnostic message as a clang-like diagnostic. + # + # @api public + # @example + # diagnostic.render # => + # # [ + # # "(fragment:0):1:5: error: unexpected token $end", + # # "foo +", + # # " ^" + # # ] + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:86 + def render; end + + private + + # If necessary, shrink a `Range` so as to include only the first line. + # + # @api public + # @return [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:142 + def first_line_only(range); end + + # If necessary, shrink a `Range` so as to include only the last line. + # + # @api public + # @return [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:155 + def last_line_only(range); end + + # Renders one source line in clang diagnostic style, with highlights. + # + # @api public + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/diagnostic.rb:110 + def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end +end + +# source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:36 +class Parser::Diagnostic::Engine + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:45 + def initialize(consumer = T.unsafe(nil)); end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:39 + def all_errors_are_fatal; end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:39 + def all_errors_are_fatal=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:37 + def consumer; end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:37 + def consumer=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:40 + def ignore_warnings; end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:40 + def ignore_warnings=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:64 + def process(diagnostic); end + + protected + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:86 + def ignore?(diagnostic); end + + # source://parser-3.1.2.1/lib/parser/diagnostic/engine.rb:97 + def raise?(diagnostic); end +end + +# Collection of the available diagnostic levels. +# +# @api public +# @return [Array] +# +# source://parser-3.1.2.1/lib/parser/diagnostic.rb:37 +Parser::Diagnostic::LEVELS = T.let(T.unsafe(nil), Array) + +# line 3 "lib/parser/lexer.rl" +# +# === BEFORE YOU START === +# +# Read the Ruby Hacking Guide chapter 11, available in English at +# http://whitequark.org/blog/2013/04/01/ruby-hacking-guide-ch-11-finite-state-lexer/ +# +# Remember two things about Ragel scanners: +# +# 1) Longest match wins. +# +# 2) If two matches have the same length, the first +# in source code wins. +# +# General rules of making Ragel and Bison happy: +# +# * `p` (position) and `@te` contain the index of the character +# they're pointing to ("current"), plus one. `@ts` contains the index +# of the corresponding character. The code for extracting matched token is: +# +# @source_buffer.slice(@ts...@te) +# +# * If your input is `foooooooobar` and the rule is: +# +# 'f' 'o'+ +# +# the result will be: +# +# foooooooobar +# ^ ts=0 ^ p=te=9 +# +# * A Ragel lexer action should not emit more than one token, unless +# you know what you are doing. +# +# * All Ragel commands (fnext, fgoto, ...) end with a semicolon. +# +# * If an action emits the token and transitions to another state, use +# these Ragel commands: +# +# emit($whatever) +# fnext $next_state; fbreak; +# +# If you perform `fgoto` in an action which does not emit a token nor +# rewinds the stream pointer, the parser's side-effectful, +# context-sensitive lookahead actions will break in a hard to detect +# and debug way. +# +# * If an action does not emit a token: +# +# fgoto $next_state; +# +# * If an action features lookbehind, i.e. matches characters with the +# intent of passing them to another action: +# +# p = @ts - 1 +# fgoto $next_state; +# +# or, if the lookbehind consists of a single character: +# +# fhold; fgoto $next_state; +# +# * Ragel merges actions. So, if you have `e_lparen = '(' %act` and +# `c_lparen = '('` and a lexer action `e_lparen | c_lparen`, the result +# _will_ invoke the action `act`. +# +# e_something stands for "something with **e**mbedded action". +# +# * EOF is explicit and is matched by `c_eof`. If you want to introspect +# the state of the lexer, add this rule to the state: +# +# c_eof => do_eof; +# +# * If you proceed past EOF, the lexer will complain: +# +# NoMethodError: undefined method `ord' for nil:NilClass +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:82 +class Parser::Lexer + # @api public + # @return [Lexer] a new instance of Lexer + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11148 + def initialize(version); end + + # Return next token: [type, value]. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11303 + def advance; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def cmdarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def cmdarg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11146 + def cmdarg_stack; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def command_start; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def command_start=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11144 + def comments; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11144 + def comments=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def cond; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def cond=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11146 + def cond_stack; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def context; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11142 + def context=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11295 + def dedent_level; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11138 + def diagnostics; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11138 + def diagnostics=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11245 + def encoding; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11140 + def force_utf32; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11140 + def force_utf32=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11146 + def lambda_stack; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11146 + def paren_nest; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11282 + def pop_cmdarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11291 + def pop_cond; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11277 + def push_cmdarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11286 + def push_cond; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11159 + def reset(reset_state = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11136 + def source_buffer; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11224 + def source_buffer=(source_buffer); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11269 + def state; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11273 + def state=(state); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11139 + def static_env; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11139 + def static_env=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11144 + def tokens; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11144 + def tokens=(_arg0); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24883 + def arg_or_cmdarg(cmd_state); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24903 + def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24857 + def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24891 + def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24873 + def emit_do(do_block = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24867 + def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24845 + def encode_escape(ord); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24832 + def eof_codepoint?(point); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24946 + def literal; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24918 + def next_state_for_literal(literal); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24950 + def pop_literal; end + + # === LITERAL STACK === + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24912 + def push_literal(*args); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24853 + def range(s = T.unsafe(nil), e = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24840 + def stack_pop; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24849 + def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:24836 + def version?(*versions); end + + class << self + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11080 + def lex_en_expr_arg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11080 + def lex_en_expr_arg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11096 + def lex_en_expr_beg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11096 + def lex_en_expr_beg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11084 + def lex_en_expr_cmdarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11084 + def lex_en_expr_cmdarg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11076 + def lex_en_expr_dot; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11076 + def lex_en_expr_dot=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11108 + def lex_en_expr_end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11108 + def lex_en_expr_end=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11088 + def lex_en_expr_endarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11088 + def lex_en_expr_endarg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11072 + def lex_en_expr_endfn; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11072 + def lex_en_expr_endfn=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11068 + def lex_en_expr_fname; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11068 + def lex_en_expr_fname=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11100 + def lex_en_expr_labelarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11100 + def lex_en_expr_labelarg=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11092 + def lex_en_expr_mid; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11092 + def lex_en_expr_mid=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11104 + def lex_en_expr_value; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11104 + def lex_en_expr_value=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11064 + def lex_en_expr_variable; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11064 + def lex_en_expr_variable=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11044 + def lex_en_interp_backslash_delimited; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11044 + def lex_en_interp_backslash_delimited=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11052 + def lex_en_interp_backslash_delimited_words; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11052 + def lex_en_interp_backslash_delimited_words=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11032 + def lex_en_interp_string; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11032 + def lex_en_interp_string=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11028 + def lex_en_interp_words; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11028 + def lex_en_interp_words=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11112 + def lex_en_leading_dot; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11112 + def lex_en_leading_dot=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11120 + def lex_en_line_begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11120 + def lex_en_line_begin=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11116 + def lex_en_line_comment; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11116 + def lex_en_line_comment=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11048 + def lex_en_plain_backslash_delimited; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11048 + def lex_en_plain_backslash_delimited=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11056 + def lex_en_plain_backslash_delimited_words; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11056 + def lex_en_plain_backslash_delimited_words=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11040 + def lex_en_plain_string; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11040 + def lex_en_plain_string=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11036 + def lex_en_plain_words; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11036 + def lex_en_plain_words=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11060 + def lex_en_regexp_modifiers; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11060 + def lex_en_regexp_modifiers=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11023 + def lex_error; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11023 + def lex_error=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11019 + def lex_start; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:11019 + def lex_start=(_arg0); end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10886 + def _lex_eof_trans; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10886 + def _lex_eof_trans=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10753 + def _lex_from_state_actions; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10753 + def _lex_from_state_actions=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:604 + def _lex_index_offsets; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:604 + def _lex_index_offsets=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:737 + def _lex_indicies; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:737 + def _lex_indicies=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:471 + def _lex_key_spans; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:471 + def _lex_key_spans=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10620 + def _lex_to_state_actions; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10620 + def _lex_to_state_actions=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10420 + def _lex_trans_actions; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10420 + def _lex_trans_actions=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:87 + def _lex_trans_keys; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:87 + def _lex_trans_keys=(_arg0); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10220 + def _lex_trans_targs; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/lexer.rb:10220 + def _lex_trans_targs=(_arg0); end + end +end + +# source://parser-3.1.2.1/lib/parser/lexer/dedenter.rb:5 +class Parser::Lexer::Dedenter + # source://parser-3.1.2.1/lib/parser/lexer/dedenter.rb:9 + def initialize(dedent_level); end + + # source://parser-3.1.2.1/lib/parser/lexer/dedenter.rb:36 + def dedent(string); end + + # source://parser-3.1.2.1/lib/parser/lexer/dedenter.rb:83 + def interrupt; end +end + +# source://parser-3.1.2.1/lib/parser/lexer/dedenter.rb:7 +Parser::Lexer::Dedenter::TAB_WIDTH = T.let(T.unsafe(nil), Integer) + +# % +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:11128 +Parser::Lexer::ESCAPES = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:24991 +Parser::Lexer::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:24998 +Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:11249 +Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash) + +# source://parser-3.1.2.1/lib/parser/lexer/literal.rb:6 +class Parser::Lexer::Literal + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:40 + def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:114 + def backslash_delimited?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:37 + def dedent_level; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:189 + def end_interp_brace_and_try_closing; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:216 + def extend_content; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:220 + def extend_space(ts, te); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:195 + def extend_string(string, ts, te); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:202 + def flush_string; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:102 + def heredoc?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:37 + def heredoc_e; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:166 + def infer_indent_level(line); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:89 + def interpolate?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:122 + def munge_escape?(character); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:132 + def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:106 + def plain_heredoc?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:98 + def regexp?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:38 + def saved_herebody_s; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:38 + def saved_herebody_s=(_arg0); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:110 + def squiggly_heredoc?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:185 + def start_interp_brace; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:37 + def str_s; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:230 + def supports_line_continuation_via_slash?; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:118 + def type; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:93 + def words?; end + + protected + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:248 + def clear_buffer; end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:244 + def coerce_encoding(string); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:236 + def delimiter?(delimiter); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:264 + def emit(token, type, s, e); end + + # source://parser-3.1.2.1/lib/parser/lexer/literal.rb:259 + def emit_start_tok; end +end + +# source://parser-3.1.2.1/lib/parser/lexer/literal.rb:7 +Parser::Lexer::Literal::DELIMITERS = T.let(T.unsafe(nil), Hash) + +# source://parser-3.1.2.1/lib/parser/lexer/literal.rb:9 +Parser::Lexer::Literal::TYPES = T.let(T.unsafe(nil), Hash) + +# Mapping of strings to parser tokens. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:24965 +Parser::Lexer::PUNCTUATION = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:24985 +Parser::Lexer::PUNCTUATION_BEGIN = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/lexer.rb:11134 +Parser::Lexer::REGEXP_META_CHARACTERS = T.let(T.unsafe(nil), Regexp) + +# source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:5 +class Parser::Lexer::StackState + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:6 + def initialize(name); end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:34 + def active?; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:11 + def clear; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:38 + def empty?; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:42 + def inspect; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:29 + def lexpop; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:22 + def pop; end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:15 + def push(bit); end + + # source://parser-3.1.2.1/lib/parser/lexer/stack_state.rb:42 + def to_s; end +end + +# Diagnostic messages (errors, warnings and notices) that can be generated. +# +# @api public +# @see Diagnostic +# +# source://parser-3.1.2.1/lib/parser/messages.rb:11 +Parser::MESSAGES = T.let(T.unsafe(nil), Hash) + +# Holds p->max_numparam from parse.y +# +# @api private +# +# source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:8 +class Parser::MaxNumparamStack + # @api private + # @return [MaxNumparamStack] a new instance of MaxNumparamStack + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:13 + def initialize; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:17 + def empty?; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:29 + def has_numparams?; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:21 + def has_ordinary_params!; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:25 + def has_ordinary_params?; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:45 + def pop; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:41 + def push(static:); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:33 + def register(numparam); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:9 + def stack; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:37 + def top; end + + private + + # @api private + # + # source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:51 + def set(value); end +end + +# @api private +# +# source://parser-3.1.2.1/lib/parser/max_numparam_stack.rb:11 +Parser::MaxNumparamStack::ORDINARY_PARAMS = T.let(T.unsafe(nil), Integer) + +# @api private +# +# source://parser-3.1.2.1/lib/parser/messages.rb:105 +module Parser::Messages + class << self + # Formats the message, returns a raw template if there's nothing to interpolate + # + # Code like `format("", {})` gives a warning, and so this method tries interpolating + # only if `arguments` hash is not empty. + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/messages.rb:112 + def compile(reason, arguments); end + end +end + +# Parser metadata +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/meta.rb:5 +module Parser::Meta; end + +# All node types that parser can produce. Not all parser versions +# will be able to produce every possible node. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/meta.rb:9 +Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set) + +# {Parser::Rewriter} is deprecated. Use {Parser::TreeRewriter} instead. +# It has a backwards compatible API and uses {Parser::Source::TreeRewriter} +# instead of {Parser::Source::Rewriter}. +# Please check the documentation for {Parser::Source::Rewriter} for details. +# +# @api public +# @deprecated Use {Parser::TreeRewriter} +# +# source://parser-3.1.2.1/lib/parser/rewriter.rb:22 +class Parser::Rewriter < ::Parser::AST::Processor + extend ::Parser::Deprecation + + # @api public + # @return [Rewriter] a new instance of Rewriter + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:98 + def initialize(*_arg0); end + + # Returns `true` if the specified node is an assignment node, returns false + # otherwise. + # + # @api public + # @param node [Parser::AST::Node] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:38 + def assignment?(node); end + + # Inserts new code after the given source range. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:77 + def insert_after(range, content); end + + # Inserts new code before the given source range. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:67 + def insert_before(range, content); end + + # Removes the source range. + # + # @api public + # @param range [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:47 + def remove(range); end + + # Replaces the code of the source range `range` with `content`. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:87 + def replace(range, content); end + + # Rewrites the AST/source buffer and returns a String containing the new + # version. + # + # @api public + # @param source_buffer [Parser::Source::Buffer] + # @param ast [Parser::AST::Node] + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:23 + def rewrite(source_buffer, ast); end + + # Wraps the given source range with the given values. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/rewriter.rb:57 + def wrap(range, before, after); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/rewriter.rb:91 +Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/ruby27.rb:14 +class Parser::Ruby27 < ::Parser::Base + # reduce 0 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3875 + def _reduce_1(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3929 + def _reduce_10(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4505 + def _reduce_100(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4515 + def _reduce_101(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4521 + def _reduce_102(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4531 + def _reduce_103(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4538 + def _reduce_104(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4545 + def _reduce_105(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4551 + def _reduce_106(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4557 + def _reduce_107(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4563 + def _reduce_108(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4569 + def _reduce_109(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3935 + def _reduce_11(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4575 + def _reduce_110(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4581 + def _reduce_111(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4587 + def _reduce_112(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4594 + def _reduce_113(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4601 + def _reduce_114(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4607 + def _reduce_115(val, _values, result); end + + # reduce 116 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4615 + def _reduce_117(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4621 + def _reduce_118(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4627 + def _reduce_119(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3952 + def _reduce_12(val, _values, result); end + + # reduce 124 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4643 + def _reduce_125(val, _values, result); end + + # reduce 126 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4651 + def _reduce_127(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4657 + def _reduce_128(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4663 + def _reduce_129(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3958 + def _reduce_13(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3964 + def _reduce_14(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3970 + def _reduce_15(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3976 + def _reduce_16(val, _values, result); end + + # reduce 17 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3984 + def _reduce_18(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3990 + def _reduce_19(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3882 + def _reduce_2(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3996 + def _reduce_20(val, _values, result); end + + # reduce 200 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4811 + def _reduce_201(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4817 + def _reduce_202(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4823 + def _reduce_203(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4832 + def _reduce_204(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4841 + def _reduce_205(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4850 + def _reduce_206(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4859 + def _reduce_207(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4867 + def _reduce_208(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4875 + def _reduce_209(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4002 + def _reduce_21(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4881 + def _reduce_210(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4887 + def _reduce_211(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4893 + def _reduce_212(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4899 + def _reduce_213(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4905 + def _reduce_214(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4911 + def _reduce_215(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4917 + def _reduce_216(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4923 + def _reduce_217(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4929 + def _reduce_218(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4935 + def _reduce_219(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4010 + def _reduce_22(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4941 + def _reduce_220(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4947 + def _reduce_221(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4953 + def _reduce_222(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4961 + def _reduce_223(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4967 + def _reduce_224(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4973 + def _reduce_225(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4979 + def _reduce_226(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4985 + def _reduce_227(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4991 + def _reduce_228(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4018 + def _reduce_23(val, _values, result); end + + # reduce 229 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4999 + def _reduce_230(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5005 + def _reduce_231(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5011 + def _reduce_232(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5017 + def _reduce_233(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5023 + def _reduce_234(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5029 + def _reduce_235(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5035 + def _reduce_236(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5041 + def _reduce_237(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5047 + def _reduce_238(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5053 + def _reduce_239(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4024 + def _reduce_24(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5059 + def _reduce_240(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5065 + def _reduce_241(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5071 + def _reduce_242(val, _values, result); end + + # reduce 247 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5088 + def _reduce_248(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5094 + def _reduce_249(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4030 + def _reduce_25(val, _values, result); end + + # reduce 252 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5106 + def _reduce_253(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5112 + def _reduce_254(val, _values, result); end + + # reduce 255 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5120 + def _reduce_256(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5130 + def _reduce_257(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5136 + def _reduce_258(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5146 + def _reduce_259(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4037 + def _reduce_26(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5156 + def _reduce_260(val, _values, result); end + + # reduce 261 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5164 + def _reduce_262(val, _values, result); end + + # reduce 264 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5174 + def _reduce_265(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5180 + def _reduce_266(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5186 + def _reduce_267(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5192 + def _reduce_268(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5198 + def _reduce_269(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4044 + def _reduce_27(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5205 + def _reduce_270(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5213 + def _reduce_271(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5219 + def _reduce_272(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5246 + def _reduce_273(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5267 + def _reduce_274(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5273 + def _reduce_275(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5279 + def _reduce_276(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5285 + def _reduce_277(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5291 + def _reduce_278(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5297 + def _reduce_279(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4050 + def _reduce_28(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5303 + def _reduce_280(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5309 + def _reduce_281(val, _values, result); end + + # reduce 282 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5317 + def _reduce_283(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5323 + def _reduce_284(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5329 + def _reduce_285(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4056 + def _reduce_29(val, _values, result); end + + # reduce 295 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5355 + def _reduce_296(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5361 + def _reduce_297(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5367 + def _reduce_298(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5375 + def _reduce_299(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3891 + def _reduce_3(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4066 + def _reduce_30(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5381 + def _reduce_300(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5387 + def _reduce_301(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5393 + def _reduce_302(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5399 + def _reduce_303(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5405 + def _reduce_304(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5411 + def _reduce_305(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5417 + def _reduce_306(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5423 + def _reduce_307(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5429 + def _reduce_308(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5435 + def _reduce_309(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5441 + def _reduce_310(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5447 + def _reduce_311(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5453 + def _reduce_312(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5460 + def _reduce_313(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5466 + def _reduce_314(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5472 + def _reduce_315(val, _values, result); end + + # reduce 316 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5484 + def _reduce_317(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5492 + def _reduce_318(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5499 + def _reduce_319(val, _values, result); end + + # reduce 31 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4074 + def _reduce_32(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5511 + def _reduce_320(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5520 + def _reduce_321(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5529 + def _reduce_322(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5535 + def _reduce_323(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5541 + def _reduce_324(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5551 + def _reduce_325(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5561 + def _reduce_326(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5571 + def _reduce_327(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5577 + def _reduce_328(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5584 + def _reduce_329(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4080 + def _reduce_33(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5601 + def _reduce_330(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5609 + def _reduce_331(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5621 + def _reduce_332(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5628 + def _reduce_333(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5643 + def _reduce_334(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5652 + def _reduce_335(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5663 + def _reduce_336(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5669 + def _reduce_337(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5678 + def _reduce_338(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5689 + def _reduce_339(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4087 + def _reduce_34(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5695 + def _reduce_340(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5701 + def _reduce_341(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5707 + def _reduce_342(val, _values, result); end + + # reduce 343 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5715 + def _reduce_344(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5721 + def _reduce_345(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5727 + def _reduce_346(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5733 + def _reduce_347(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4098 + def _reduce_35(val, _values, result); end + + # reduce 349 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5745 + def _reduce_350(val, _values, result); end + + # reduce 353 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5757 + def _reduce_354(val, _values, result); end + + # reduce 355 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5770 + def _reduce_356(val, _values, result); end + + # reduce 358 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5780 + def _reduce_359(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5786 + def _reduce_360(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5792 + def _reduce_361(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5798 + def _reduce_362(val, _values, result); end + + # reduce 363 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5806 + def _reduce_364(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5813 + def _reduce_365(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5821 + def _reduce_366(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5827 + def _reduce_367(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5833 + def _reduce_368(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5839 + def _reduce_369(val, _values, result); end + + # reduce 36 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4106 + def _reduce_37(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5845 + def _reduce_370(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5851 + def _reduce_371(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5857 + def _reduce_372(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5863 + def _reduce_373(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5869 + def _reduce_374(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5875 + def _reduce_375(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5881 + def _reduce_376(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5887 + def _reduce_377(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5896 + def _reduce_378(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5906 + def _reduce_379(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4112 + def _reduce_38(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5914 + def _reduce_380(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5923 + def _reduce_381(val, _values, result); end + + # reduce 382 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5933 + def _reduce_383(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5942 + def _reduce_384(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5952 + def _reduce_385(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5960 + def _reduce_386(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5969 + def _reduce_387(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5976 + def _reduce_388(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5984 + def _reduce_389(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4118 + def _reduce_39(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:5991 + def _reduce_390(val, _values, result); end + + # reduce 391 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6001 + def _reduce_392(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6007 + def _reduce_393(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6013 + def _reduce_394(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6021 + def _reduce_395(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6029 + def _reduce_396(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6035 + def _reduce_397(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6041 + def _reduce_398(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6047 + def _reduce_399(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3897 + def _reduce_4(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4127 + def _reduce_40(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6053 + def _reduce_400(val, _values, result); end + + # reduce 401 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6062 + def _reduce_402(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6069 + def _reduce_403(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6075 + def _reduce_404(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6086 + def _reduce_405(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6093 + def _reduce_406(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6102 + def _reduce_407(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6109 + def _reduce_408(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6116 + def _reduce_409(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4136 + def _reduce_41(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6123 + def _reduce_410(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6130 + def _reduce_411(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6137 + def _reduce_412(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6144 + def _reduce_413(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6152 + def _reduce_414(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6160 + def _reduce_415(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6172 + def _reduce_416(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6183 + def _reduce_417(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6191 + def _reduce_418(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6199 + def _reduce_419(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4145 + def _reduce_42(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6207 + def _reduce_420(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6213 + def _reduce_421(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6221 + def _reduce_422(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6229 + def _reduce_423(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6237 + def _reduce_424(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6243 + def _reduce_425(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6249 + def _reduce_426(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6256 + def _reduce_427(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6263 + def _reduce_428(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6270 + def _reduce_429(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4153 + def _reduce_43(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6277 + def _reduce_430(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6284 + def _reduce_431(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6294 + def _reduce_432(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6301 + def _reduce_433(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6307 + def _reduce_434(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6318 + def _reduce_435(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6325 + def _reduce_436(val, _values, result); end + + # reduce 437 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6333 + def _reduce_438(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6345 + def _reduce_439(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4162 + def _reduce_44(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6353 + def _reduce_440(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6360 + def _reduce_441(val, _values, result); end + + # reduce 442 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6368 + def _reduce_443(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6374 + def _reduce_444(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6380 + def _reduce_445(val, _values, result); end + + # reduce 446 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6388 + def _reduce_447(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6398 + def _reduce_448(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6404 + def _reduce_449(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6410 + def _reduce_450(val, _values, result); end + + # reduce 451 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6418 + def _reduce_452(val, _values, result); end + + # reduce 453 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6426 + def _reduce_454(val, _values, result); end + + # reduce 455 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6434 + def _reduce_456(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6441 + def _reduce_457(val, _values, result); end + + # reduce 458 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6450 + def _reduce_459(val, _values, result); end + + # reduce 45 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4170 + def _reduce_46(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6458 + def _reduce_460(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6466 + def _reduce_461(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6473 + def _reduce_462(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6481 + def _reduce_463(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6489 + def _reduce_464(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6496 + def _reduce_465(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6502 + def _reduce_466(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6509 + def _reduce_467(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6515 + def _reduce_468(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6523 + def _reduce_469(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6531 + def _reduce_470(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6537 + def _reduce_471(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6543 + def _reduce_472(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6550 + def _reduce_473(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6556 + def _reduce_474(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6562 + def _reduce_475(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6568 + def _reduce_476(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6575 + def _reduce_477(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6582 + def _reduce_478(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6588 + def _reduce_479(val, _values, result); end + + # reduce 480 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6596 + def _reduce_481(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6606 + def _reduce_482(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6616 + def _reduce_483(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6623 + def _reduce_484(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6630 + def _reduce_485(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6637 + def _reduce_486(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6644 + def _reduce_487(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6650 + def _reduce_488(val, _values, result); end + + # reduce 48 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4184 + def _reduce_49(val, _values, result); end + + # reduce 489 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6658 + def _reduce_490(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6664 + def _reduce_491(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6670 + def _reduce_492(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6676 + def _reduce_493(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6682 + def _reduce_494(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6688 + def _reduce_495(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6694 + def _reduce_496(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6700 + def _reduce_497(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6706 + def _reduce_498(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6712 + def _reduce_499(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3903 + def _reduce_5(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4190 + def _reduce_50(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6718 + def _reduce_500(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6724 + def _reduce_501(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6730 + def _reduce_502(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6736 + def _reduce_503(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6742 + def _reduce_504(val, _values, result); end + + # reduce 505 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6750 + def _reduce_506(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6756 + def _reduce_507(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6762 + def _reduce_508(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6768 + def _reduce_509(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4196 + def _reduce_51(val, _values, result); end + + # reduce 512 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6780 + def _reduce_513(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6786 + def _reduce_514(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4202 + def _reduce_52(val, _values, result); end + + # reduce 522 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6808 + def _reduce_523(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6814 + def _reduce_524(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6821 + def _reduce_525(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6833 + def _reduce_526(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6839 + def _reduce_527(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6851 + def _reduce_528(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6857 + def _reduce_529(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4208 + def _reduce_53(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6863 + def _reduce_530(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6869 + def _reduce_531(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6884 + def _reduce_532(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6890 + def _reduce_533(val, _values, result); end + + # reduce 535 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6900 + def _reduce_536(val, _values, result); end + + # reduce 537 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6908 + def _reduce_538(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4219 + def _reduce_54(val, _values, result); end + + # reduce 541 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6920 + def _reduce_542(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6926 + def _reduce_543(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6932 + def _reduce_544(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6938 + def _reduce_545(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6945 + def _reduce_546(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6952 + def _reduce_547(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6958 + def _reduce_548(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6965 + def _reduce_549(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6972 + def _reduce_550(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6978 + def _reduce_551(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6984 + def _reduce_552(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6990 + def _reduce_553(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:6996 + def _reduce_554(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7002 + def _reduce_555(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7008 + def _reduce_556(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7014 + def _reduce_557(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7020 + def _reduce_558(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7026 + def _reduce_559(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7032 + def _reduce_560(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7038 + def _reduce_561(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7044 + def _reduce_562(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7050 + def _reduce_563(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7056 + def _reduce_564(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7062 + def _reduce_565(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7068 + def _reduce_566(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7074 + def _reduce_567(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7080 + def _reduce_568(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7086 + def _reduce_569(val, _values, result); end + + # reduce 56 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4235 + def _reduce_57(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7092 + def _reduce_570(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7098 + def _reduce_571(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7104 + def _reduce_572(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7111 + def _reduce_573(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7120 + def _reduce_574(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7126 + def _reduce_575(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7132 + def _reduce_576(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4241 + def _reduce_58(val, _values, result); end + + # reduce 579 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7144 + def _reduce_580(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7151 + def _reduce_581(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7158 + def _reduce_582(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7164 + def _reduce_583(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7175 + def _reduce_584(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7182 + def _reduce_585(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7189 + def _reduce_586(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7196 + def _reduce_587(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7203 + def _reduce_588(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7209 + def _reduce_589(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7215 + def _reduce_590(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7221 + def _reduce_591(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7227 + def _reduce_592(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7233 + def _reduce_593(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7239 + def _reduce_594(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7245 + def _reduce_595(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7251 + def _reduce_596(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7257 + def _reduce_597(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7263 + def _reduce_598(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7269 + def _reduce_599(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3909 + def _reduce_6(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7275 + def _reduce_600(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7281 + def _reduce_601(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7287 + def _reduce_602(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7293 + def _reduce_603(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7299 + def _reduce_604(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7305 + def _reduce_605(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7311 + def _reduce_606(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7317 + def _reduce_607(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7323 + def _reduce_608(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7329 + def _reduce_609(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7337 + def _reduce_610(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7345 + def _reduce_611(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7354 + def _reduce_612(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7361 + def _reduce_613(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7368 + def _reduce_614(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7374 + def _reduce_615(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7380 + def _reduce_616(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7386 + def _reduce_617(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7392 + def _reduce_618(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7398 + def _reduce_619(val, _values, result); end + + # reduce 61 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4254 + def _reduce_62(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7404 + def _reduce_620(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7410 + def _reduce_621(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7419 + def _reduce_622(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7429 + def _reduce_623(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7437 + def _reduce_624(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7446 + def _reduce_625(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7454 + def _reduce_626(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7463 + def _reduce_627(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7470 + def _reduce_628(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7478 + def _reduce_629(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4261 + def _reduce_63(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7487 + def _reduce_630(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7494 + def _reduce_631(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7502 + def _reduce_632(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7509 + def _reduce_633(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7517 + def _reduce_634(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7523 + def _reduce_635(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7529 + def _reduce_636(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7535 + def _reduce_637(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7541 + def _reduce_638(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7547 + def _reduce_639(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4268 + def _reduce_64(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7553 + def _reduce_640(val, _values, result); end + + # reduce 641 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7561 + def _reduce_642(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7571 + def _reduce_643(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7578 + def _reduce_644(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7585 + def _reduce_645(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7591 + def _reduce_646(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7597 + def _reduce_647(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7603 + def _reduce_648(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7617 + def _reduce_649(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7624 + def _reduce_650(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7631 + def _reduce_651(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7637 + def _reduce_652(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7643 + def _reduce_653(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7649 + def _reduce_654(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7655 + def _reduce_655(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7661 + def _reduce_656(val, _values, result); end + + # reduce 658 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7671 + def _reduce_659(val, _values, result); end + + # reduce 65 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4277 + def _reduce_66(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7677 + def _reduce_660(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7685 + def _reduce_661(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7691 + def _reduce_662(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7698 + def _reduce_663(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7705 + def _reduce_664(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7711 + def _reduce_665(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7717 + def _reduce_666(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7723 + def _reduce_667(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4284 + def _reduce_67(val, _values, result); end + + # reduce 669 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7733 + def _reduce_670(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7741 + def _reduce_671(val, _values, result); end + + # reduce 673 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7751 + def _reduce_674(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7759 + def _reduce_675(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7765 + def _reduce_676(val, _values, result); end + + # reduce 677 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7773 + def _reduce_678(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7779 + def _reduce_679(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4295 + def _reduce_68(val, _values, result); end + + # reduce 680 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7787 + def _reduce_681(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7793 + def _reduce_682(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7799 + def _reduce_683(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7805 + def _reduce_684(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7811 + def _reduce_685(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7817 + def _reduce_686(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4302 + def _reduce_69(val, _values, result); end + + # reduce 698 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7847 + def _reduce_699(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3915 + def _reduce_7(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4313 + def _reduce_70(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7853 + def _reduce_700(val, _values, result); end + + # reduce 704 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7867 + def _reduce_705(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7873 + def _reduce_706(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7879 + def _reduce_707(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4320 + def _reduce_71(val, _values, result); end + + # reduce 710 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7891 + def _reduce_711(val, _values, result); end + + # reduce 714 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7903 + def _reduce_715(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4331 + def _reduce_72(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4338 + def _reduce_73(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4345 + def _reduce_74(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4352 + def _reduce_75(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4359 + def _reduce_76(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4366 + def _reduce_77(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4372 + def _reduce_78(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4378 + def _reduce_79(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4384 + def _reduce_80(val, _values, result); end + + # reduce 81 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4392 + def _reduce_82(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4399 + def _reduce_83(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4406 + def _reduce_84(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4414 + def _reduce_85(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4421 + def _reduce_86(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4429 + def _reduce_87(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4435 + def _reduce_88(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4442 + def _reduce_89(val, _values, result); end + + # reduce 8 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:3923 + def _reduce_9(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4448 + def _reduce_90(val, _values, result); end + + # reduce 91 omitted + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4457 + def _reduce_92(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4463 + def _reduce_93(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4469 + def _reduce_94(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4475 + def _reduce_95(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4481 + def _reduce_96(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4487 + def _reduce_97(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4493 + def _reduce_98(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:4499 + def _reduce_99(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:7909 + def _reduce_none(val, _values, result); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:21 + def default_encoding; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:32 + def local_pop; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:25 + def local_push; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:39 + def try_declare_numparam(node); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/ruby27.rb:17 + def version; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/ruby27.rb:3476 +Parser::Ruby27::Racc_arg = T.let(T.unsafe(nil), Array) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/ruby27.rb:3492 +Parser::Ruby27::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) + +# @api public +# +# source://parser-3.1.2.1/lib/parser.rb:30 +module Parser::Source; end + +# A buffer with source code. {Buffer} contains the source code itself, +# associated location information (name and first line), and takes care +# of encoding. +# +# A source buffer is immutable once populated. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/buffer.rb:25 +class Parser::Source::Buffer + # @api public + # @return [Buffer] a new instance of Buffer + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:105 + def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end + + # Convert a character index into the source to a column number. + # + # @api private + # @param position [Integer] + # @return [Integer] column + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:233 + def column_for_position(position); end + + # Convert a character index into the source to a `[line, column]` tuple. + # + # @api public + # @param position [Integer] + # @return [[Integer, Integer]] `[line, column]` + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:208 + def decompose_position(position); end + + # First line of the buffer, 1 by default. + # + # @api public + # @return [Integer] first line + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:26 + def first_line; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:303 + def freeze; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:309 + def inspect; end + + # Number of last line in the buffer + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:298 + def last_line; end + + # Convert a character index into the source to a line number. + # + # @api private + # @param position [Integer] + # @return [Integer] line + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:222 + def line_for_position(position); end + + # Extract line `lineno` as a new `Range`, taking `first_line` into account. + # + # @api public + # @param lineno [Integer] + # @raise [IndexError] if `lineno` is out of bounds + # @return [Range] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:275 + def line_range(lineno); end + + # Buffer name. If the buffer was created from a file, the name corresponds + # to relative path to the file. + # + # @api public + # @return [String] buffer name + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:26 + def name; end + + # Populate this buffer from a string without encoding autodetection. + # + # @api public + # @param input [String] + # @raise [ArgumentError] if already populated + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:180 + def raw_source=(input); end + + # Populate this buffer from correspondingly named file. + # + # @api public + # @example + # Parser::Source::Buffer.new('foo/bar.rb').read + # @raise [ArgumentError] if already populated + # @return [Buffer] self + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:131 + def read; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:194 + def slice(range); end + + # Source code contained in this buffer. + # + # @api public + # @raise [RuntimeError] if buffer is not populated yet + # @return [String] source code + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:145 + def source; end + + # Populate this buffer from a string with encoding autodetection. + # `input` is mutated if not frozen. + # + # @api public + # @param input [String] + # @raise [ArgumentError] if already populated + # @raise [EncodingError] if `input` includes invalid byte sequence for the encoding + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:162 + def source=(input); end + + # Extract line `lineno` from source, taking `first_line` into account. + # + # @api public + # @param lineno [Integer] + # @raise [IndexError] if `lineno` is out of bounds + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:264 + def source_line(lineno); end + + # Return an `Array` of source code lines. + # + # @api public + # @return [Array] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:243 + def source_lines; end + + # @api public + # @return [Range] A range covering the whole source + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:289 + def source_range; end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:339 + def bsearch(line_begins, position); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:316 + def line_begins; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:330 + def line_index_for_position(position); end + + class << self + # Try to recognize encoding of `string` as Ruby would, i.e. by looking for + # magic encoding comment or UTF-8 BOM. `string` can be in any encoding. + # + # @api public + # @param string [String] + # @return [String, nil] encoding name, if recognized + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:51 + def recognize_encoding(string); end + + # Recognize encoding of `input` and process it so it could be lexed. + # + # * If `input` does not contain BOM or magic encoding comment, it is + # kept in the original encoding. + # * If the detected encoding is binary, `input` is kept in binary. + # * Otherwise, `input` is re-encoded into UTF-8 and returned as a + # new string. + # + # This method mutates the encoding of `input`, but not its content. + # + # @api public + # @param input [String] + # @raise [EncodingError] + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/buffer.rb:90 + def reencode_string(input); end + end +end + +# @api private +# +# source://parser-3.1.2.1/lib/parser/source/buffer.rb:31 +Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp) + +# A comment in the source code. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/comment.rb:17 +class Parser::Source::Comment + # @api public + # @param range [Parser::Source::Range] + # @return [Comment] a new instance of Comment + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:67 + def initialize(range); end + + # Compares comments. Two comments are equal if they + # correspond to the same source range. + # + # @api public + # @param other [Object] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:120 + def ==(other); end + + # @api public + # @return [Boolean] true if this is a block comment. + # @see #type + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:109 + def document?; end + + # @api public + # @return [Boolean] true if this is an inline comment. + # @see #type + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:101 + def inline?; end + + # @api public + # @return [String] a human-readable representation of this comment + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:128 + def inspect; end + + # @api public + # @return [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:20 + def loc; end + + # @api public + # @return [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:20 + def location; end + + # @api public + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:18 + def text; end + + # Type of this comment. + # + # * Inline comments correspond to `:inline`: + # + # # whatever + # + # * Block comments correspond to `:document`: + # + # =begin + # hi i am a document + # =end + # + # @api public + # @return [Symbol] + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:89 + def type; end + + class << self + # Associate `comments` with `ast` nodes by their corresponding node. + # + # @api public + # @deprecated Use {associate_locations}. + # @param ast [Parser::AST::Node] + # @param comments [Array] + # @return [Hash>] + # @see Parser::Source::Comment::Associator#associate + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:32 + def associate(ast, comments); end + + # Associate `comments` with `ast` nodes using identity. + # + # @api public + # @param ast [Parser::AST::Node] + # @param comments [Array] + # @return [Hash>] + # @see Parser::Source::Comment::Associator#associate_by_identity + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:59 + def associate_by_identity(ast, comments); end + + # Associate `comments` with `ast` nodes by their location in the + # source. + # + # @api public + # @param ast [Parser::AST::Node] + # @param comments [Array] + # @return [Hash>] + # @see Parser::Source::Comment::Associator#associate_locations + # + # source://parser-3.1.2.1/lib/parser/source/comment.rb:46 + def associate_locations(ast, comments); end + end +end + +# source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:45 +class Parser::Source::Comment::Associator + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:51 + def initialize(ast, comments); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:92 + def associate; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:115 + def associate_by_identity; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:103 + def associate_locations; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:46 + def skip_directives; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:46 + def skip_directives=(_arg0); end + + private + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:182 + def advance_comment; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:214 + def advance_through_directives; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:206 + def associate_and_advance_comment(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:123 + def children_in_source_order(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:187 + def current_comment_before?(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:194 + def current_comment_before_end?(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:201 + def current_comment_decorates?(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:135 + def do_associate; end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:166 + def process_leading_comments(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:173 + def process_trailing_comments(node); end + + # source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:148 + def visit(node); end +end + +# source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:212 +Parser::Source::Comment::Associator::MAGIC_COMMENT_RE = T.let(T.unsafe(nil), Regexp) + +# source://parser-3.1.2.1/lib/parser/source/comment/associator.rb:122 +Parser::Source::Comment::Associator::POSTFIX_TYPES = T.let(T.unsafe(nil), Set) + +# {Map} relates AST nodes to the source code they were parsed from. +# More specifically, a {Map} or its subclass contains a set of ranges: +# +# * `expression`: smallest range which includes all source corresponding +# to the node and all `expression` ranges of its children. +# * other ranges (`begin`, `end`, `operator`, ...): node-specific ranges +# pointing to various interesting tokens corresponding to the node. +# +# Note that the {Map::Heredoc} map is the only one whose `expression` does +# not include other ranges. It only covers the heredoc marker (`< 2]').children[0].loc +# # => > +# +# The {file:doc/AST_FORMAT.md} document describes how ranges associated to source +# code tokens. For example, the entry +# +# (array (int 1) (int 2)) +# +# "[1, 2]" +# ^ begin +# ^ end +# ~~~~~~ expression +# +# means that if `node` is an {Parser::AST::Node} `(array (int 1) (int 2))`, +# then `node.loc` responds to `begin`, `end` and `expression`, and +# `node.loc.begin` returns a range pointing at the opening bracket, and so on. +# +# If you want to write code polymorphic by the source map (i.e. accepting +# several subclasses of {Map}), use `respond_to?` instead of `is_a?` to +# check whether the map features the range you need. Concrete {Map} +# subclasses may not be preserved between versions, but their interfaces +# will be kept compatible. +# +# You can visualize the source maps with `ruby-parse -E` command-line tool. +# +# @api public +# @example +# require 'parser/current' +# +# p Parser::CurrentRuby.parse('[1, 2]').loc +# # => #, +# # @begin=#, +# # @expression=#> +# +# source://parser-3.1.2.1/lib/parser/source/map.rb:70 +class Parser::Source::Map + # @api public + # @param expression [Range] + # @return [Map] a new instance of Map + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:76 + def initialize(expression); end + + # Compares source maps. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:140 + def ==(other); end + + # A shortcut for `self.expression.column`. + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:109 + def column; end + + # @api public + # @return [Range] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:72 + def expression; end + + # A shortcut for `self.expression.line`. + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:99 + def first_line; end + + # A shortcut for `self.expression.last_column`. + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:125 + def last_column; end + + # A shortcut for `self.expression.last_line`. + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:117 + def last_line; end + + # A shortcut for `self.expression.line`. + # + # @api public + # @return [Integer] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:99 + def line; end + + # The node that is described by this map. Nodes and maps have 1:1 correspondence. + # + # @api public + # @return [Parser::AST::Node] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:71 + def node; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:89 + def node=(node); end + + # Converts this source map to a hash with keys corresponding to + # ranges. For example, if called on an instance of {Collection}, + # which adds the `begin` and `end` ranges, the resulting hash + # will contain keys `:expression`, `:begin` and `:end`. + # + # @api public + # @example + # require 'parser/current' + # + # p Parser::CurrentRuby.parse('[1, 2]').loc.to_hash + # # => { + # # :begin => #, + # # :end => #, + # # :expression => # + # # } + # @return [Hash] + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:166 + def to_hash; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:132 + def with_expression(expression_l); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:180 + def update_expression(expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:176 + def with(&block); end + + private + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map.rb:82 + def initialize_copy(other); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/collection.rb:6 +class Parser::Source::Map::Collection < ::Parser::Source::Map + # @api public + # @return [Collection] a new instance of Collection + # + # source://parser-3.1.2.1/lib/parser/source/map/collection.rb:10 + def initialize(begin_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/collection.rb:7 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/collection.rb:8 + def end; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/condition.rb:6 +class Parser::Source::Map::Condition < ::Parser::Source::Map + # @api public + # @return [Condition] a new instance of Condition + # + # source://parser-3.1.2.1/lib/parser/source/map/condition.rb:12 + def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/condition.rb:8 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/condition.rb:9 + def else; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/condition.rb:10 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/condition.rb:7 + def keyword; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/constant.rb:6 +class Parser::Source::Map::Constant < ::Parser::Source::Map + # @api public + # @return [Constant] a new instance of Constant + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:11 + def initialize(double_colon, name, expression); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:7 + def double_colon; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:8 + def name; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:9 + def operator; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:20 + def with_operator(operator_l); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/constant.rb:26 + def update_operator(operator_l); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/definition.rb:6 +class Parser::Source::Map::Definition < ::Parser::Source::Map + # @api public + # @return [Definition] a new instance of Definition + # + # source://parser-3.1.2.1/lib/parser/source/map/definition.rb:12 + def initialize(keyword_l, operator_l, name_l, end_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/definition.rb:10 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/definition.rb:7 + def keyword; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/definition.rb:9 + def name; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/definition.rb:8 + def operator; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/for.rb:6 +class Parser::Source::Map::For < ::Parser::Source::Map + # @api public + # @return [For] a new instance of For + # + # source://parser-3.1.2.1/lib/parser/source/map/for.rb:10 + def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/for.rb:8 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/for.rb:8 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/for.rb:7 + def in; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/for.rb:7 + def keyword; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/heredoc.rb:6 +class Parser::Source::Map::Heredoc < ::Parser::Source::Map + # @api public + # @return [Heredoc] a new instance of Heredoc + # + # source://parser-3.1.2.1/lib/parser/source/map/heredoc.rb:10 + def initialize(begin_l, body_l, end_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/heredoc.rb:7 + def heredoc_body; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/heredoc.rb:8 + def heredoc_end; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/index.rb:6 +class Parser::Source::Map::Index < ::Parser::Source::Map + # @api public + # @return [Index] a new instance of Index + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:11 + def initialize(begin_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:7 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:8 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:9 + def operator; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:21 + def with_operator(operator_l); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/index.rb:27 + def update_operator(operator_l); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/keyword.rb:6 +class Parser::Source::Map::Keyword < ::Parser::Source::Map + # @api public + # @return [Keyword] a new instance of Keyword + # + # source://parser-3.1.2.1/lib/parser/source/map/keyword.rb:11 + def initialize(keyword_l, begin_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/keyword.rb:8 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/keyword.rb:9 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/keyword.rb:7 + def keyword; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:6 +class Parser::Source::Map::MethodDefinition < ::Parser::Source::Map + # @api public + # @return [MethodDefinition] a new instance of MethodDefinition + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:13 + def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:11 + def assignment; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:10 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:7 + def keyword; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:9 + def name; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/method_definition.rb:8 + def operator; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/objc_kwarg.rb:6 +class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map + # @api public + # @return [ObjcKwarg] a new instance of ObjcKwarg + # + # source://parser-3.1.2.1/lib/parser/source/map/objc_kwarg.rb:11 + def initialize(keyword_l, operator_l, argument_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/objc_kwarg.rb:9 + def argument; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/objc_kwarg.rb:7 + def keyword; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/objc_kwarg.rb:8 + def operator; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/operator.rb:6 +class Parser::Source::Map::Operator < ::Parser::Source::Map + # @api public + # @return [Operator] a new instance of Operator + # + # source://parser-3.1.2.1/lib/parser/source/map/operator.rb:9 + def initialize(operator, expression); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/operator.rb:7 + def operator; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/rescue_body.rb:6 +class Parser::Source::Map::RescueBody < ::Parser::Source::Map + # @api public + # @return [RescueBody] a new instance of RescueBody + # + # source://parser-3.1.2.1/lib/parser/source/map/rescue_body.rb:11 + def initialize(keyword_l, assoc_l, begin_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/rescue_body.rb:8 + def assoc; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/rescue_body.rb:9 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/rescue_body.rb:7 + def keyword; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/send.rb:6 +class Parser::Source::Map::Send < ::Parser::Source::Map + # @api public + # @return [Send] a new instance of Send + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:13 + def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:10 + def begin; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:7 + def dot; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:11 + def end; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:9 + def operator; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:8 + def selector; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:24 + def with_operator(operator_l); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/send.rb:30 + def update_operator(operator_l); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/ternary.rb:6 +class Parser::Source::Map::Ternary < ::Parser::Source::Map + # @api public + # @return [Ternary] a new instance of Ternary + # + # source://parser-3.1.2.1/lib/parser/source/map/ternary.rb:10 + def initialize(question_l, colon_l, expression_l); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/ternary.rb:8 + def colon; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/ternary.rb:7 + def question; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/map/variable.rb:6 +class Parser::Source::Map::Variable < ::Parser::Source::Map + # @api public + # @return [Variable] a new instance of Variable + # + # source://parser-3.1.2.1/lib/parser/source/map/variable.rb:10 + def initialize(name_l, expression_l = T.unsafe(nil)); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/variable.rb:7 + def name; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/variable.rb:8 + def operator; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/map/variable.rb:19 + def with_operator(operator_l); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/map/variable.rb:25 + def update_operator(operator_l); end +end + +# A range of characters in a particular source buffer. +# +# The range is always exclusive, i.e. a range with `begin_pos` of 3 and +# `end_pos` of 5 will contain the following characters: +# +# example +# ^^ +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/range.rb:26 +class Parser::Source::Range + include ::Comparable + + # @api public + # @param source_buffer [Buffer] + # @param begin_pos [Integer] + # @param end_pos [Integer] + # @return [Range] a new instance of Range + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:37 + def initialize(source_buffer, begin_pos, end_pos); end + + # Compare ranges, first by begin_pos, then by end_pos. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:301 + def <=>(other); end + + # by the given amount(s) + # + # @api public + # @param Endpoint(s) [Hash] to change, any combination of :begin_pos or :end_pos + # @return [Range] the same range as this range but with the given end point(s) adjusted + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:193 + def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end + + # @api public + # @return [Range] a zero-length range located just before the beginning + # of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:55 + def begin; end + + # @api public + # @return [Integer] index of the first character in the range + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:30 + def begin_pos; end + + # @api public + # @return [Integer] zero-based column number of the beginning of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:92 + def column; end + + # @api public + # @raise RangeError + # @return [::Range] a range of columns spanned by this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:114 + def column_range; end + + # Return `other.contains?(self)` + # + # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing? + # + # @api public + # @param other [Range] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:274 + def contained?(other); end + + # Returns true iff this range contains (strictly) `other`. + # + # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing? + # + # @api public + # @param other [Range] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:262 + def contains?(other); end + + # Returns true iff both ranges intersect and also have different elements from one another. + # + # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing? + # + # @api public + # @param other [Range] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:286 + def crossing?(other); end + + # Return `true` iff this range and `other` are disjoint. + # + # Two ranges must be one and only one of ==, disjoint?, contains?, contained? or crossing? + # + # @api public + # @param other [Range] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:236 + def disjoint?(other); end + + # Checks if a range is empty; if it contains no characters + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:294 + def empty?; end + + # @api public + # @return [Range] a zero-length range located just after the end + # of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:63 + def end; end + + # @api public + # @return [Integer] index of the character after the last character in the range + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:30 + def end_pos; end + + # @api public + def eql?(_arg0); end + + # Line number of the beginning of this range. By default, the first line + # of a buffer is 1; as such, line numbers are most commonly one-based. + # + # @api public + # @return [Integer] line number of the beginning of this range. + # @see Buffer + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:83 + def first_line; end + + # Support for Ranges be used in as Hash indices and in Sets. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:313 + def hash; end + + # @api public + # @return [String] a human-readable representation of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:320 + def inspect; end + + # @api public + # @param other [Range] + # @return [Range] overlapping region of this range and `other`, or `nil` + # if they do not overlap + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:220 + def intersect(other); end + + # `is?` provides a concise way to compare the source corresponding to this range. + # For example, `r.source == '(' || r.source == 'begin'` is equivalent to + # `r.is?('(', 'begin')`. + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:141 + def is?(*what); end + + # @api public + # @param other [Range] + # @return [Range] smallest possible range spanning both this range and `other`. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:209 + def join(other); end + + # @api public + # @return [Integer] zero-based column number of the end of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:106 + def last_column; end + + # @api public + # @return [Integer] line number of the end of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:99 + def last_line; end + + # @api public + # @return [Integer] amount of characters included in this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:70 + def length; end + + # Line number of the beginning of this range. By default, the first line + # of a buffer is 1; as such, line numbers are most commonly one-based. + # + # @api public + # @return [Integer] line number of the beginning of this range. + # @see Buffer + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:83 + def line; end + + # Return `true` iff this range is not disjoint from `other`. + # + # @api public + # @param other [Range] + # @return [Boolean] `true` if this range and `other` overlap + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:250 + def overlaps?(other); end + + # @api public + # @param new_size [Integer] + # @return [Range] a range beginning at the same point as this range and length `new_size`. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:201 + def resize(new_size); end + + # @api public + # @return [Integer] amount of characters included in this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:70 + def size; end + + # @api public + # @return [String] all source code covered by this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:132 + def source; end + + # @api public + # @return [Parser::Source::Buffer] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:29 + def source_buffer; end + + # @api public + # @return [String] a line of source code containing the beginning of this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:125 + def source_line; end + + # @api public + # @return [Array] a set of character indexes contained in this range. + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:148 + def to_a; end + + # @api public + # @return [Range] a Ruby range with the same `begin_pos` and `end_pos` + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:155 + def to_range; end + + # Composes a GNU/Clang-style string representation of the beginning of this + # range. + # + # For example, for the following range in file `foo.rb`, + # + # def foo + # ^^^ + # + # `to_s` will return `foo.rb:1:5`. + # Note that the column index is one-based. + # + # @api public + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:173 + def to_s; end + + # to the given value(s). + # + # @api public + # @param Endpoint(s) [Hash] to change, any combination of :begin_pos or :end_pos + # @return [Range] the same range as this range but with the given end point(s) changed + # + # source://parser-3.1.2.1/lib/parser/source/range.rb:184 + def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end +end + +# {Rewriter} is deprecated. Use {TreeRewriter} instead. +# +# TreeRewriter has simplified semantics, and customizable policies +# with regards to clobbering. Please read the documentation. +# +# Keep in mind: +# - Rewriter was discarding the `end_pos` of the given range for `insert_before`, +# and the `begin_pos` for `insert_after`. These are meaningful in TreeRewriter. +# - TreeRewriter's wrap/insert_before/insert_after are multiple by default, while +# Rewriter would raise clobbering errors if the non '_multi' version was called. +# - The TreeRewriter policy closest to Rewriter's behavior is: +# different_replacements: :raise, +# swallowed_insertions: :raise, +# crossing_deletions: :accept +# +# @api public +# @deprecated Use {TreeRewriter} +# +# source://parser-3.1.2.1/lib/parser/source/rewriter.rb:31 +class Parser::Source::Rewriter + extend ::Parser::Deprecation + + # @api public + # @deprecated Use {TreeRewriter} + # @param source_buffer [Source::Buffer] + # @return [Rewriter] a new instance of Rewriter + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:39 + def initialize(source_buffer); end + + # @api public + # @return [Diagnostic::Engine] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:33 + def diagnostics; end + + # Inserts new code after the given source range. + # + # @api public + # @deprecated Use {TreeRewriter#insert_after} + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:131 + def insert_after(range, content); end + + # Inserts new code after the given source range by allowing other + # insertions at the same position. + # Note that an insertion with latter invocation comes _after_ earlier + # insertion at the same position in the rewritten source. + # + # @api public + # @deprecated Use {TreeRewriter#insert_after} + # @example Inserting ')]' + # rewriter. + # insert_after_multi(range, ')'). + # insert_after_multi(range, ']'). + # process + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:153 + def insert_after_multi(range, content); end + + # Inserts new code before the given source range. + # + # @api public + # @deprecated Use {TreeRewriter#insert_before} + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:80 + def insert_before(range, content); end + + # Inserts new code before the given source range by allowing other + # insertions at the same position. + # Note that an insertion with latter invocation comes _before_ earlier + # insertion at the same position in the rewritten source. + # + # @api public + # @deprecated Use {TreeRewriter#insert_before} + # @example Inserting '[(' + # rewriter. + # insert_before_multi(range, '('). + # insert_before_multi(range, '['). + # process + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:117 + def insert_before_multi(range, content); end + + # Applies all scheduled changes to the `source_buffer` and returns + # modified source as a new string. + # + # @api public + # @deprecated Use {TreeRewriter#process} + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:178 + def process; end + + # Removes the source range. + # + # @api public + # @deprecated Use {TreeRewriter#remove} + # @param range [Range] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:67 + def remove(range); end + + # Replaces the code of the source range `range` with `content`. + # + # @api public + # @deprecated Use {TreeRewriter#replace} + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:167 + def replace(range, content); end + + # @api public + # @return [Source::Buffer] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:32 + def source_buffer; end + + # Provides a protected block where a sequence of multiple rewrite actions + # are handled atomically. If any of the actions failed by clobbering, + # all the actions are rolled back. + # + # @api public + # @deprecated Use {TreeRewriter#transaction} + # @example + # begin + # rewriter.transaction do + # rewriter.insert_before(range_of_something, '(') + # rewriter.insert_after(range_of_something, ')') + # end + # rescue Parser::ClobberingError + # end + # @raise [RuntimeError] when no block is passed + # @raise [RuntimeError] when already in a transaction + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:216 + def transaction; end + + # Inserts new code before and after the given source range. + # + # @api public + # @deprecated Use {TreeRewriter#wrap} + # @param range [Range] + # @param before [String] + # @param after [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:94 + def wrap(range, before, after); end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:476 + def active_clobber; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:484 + def active_clobber=(value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:480 + def active_insertions; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:492 + def active_insertions=(value); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:472 + def active_queue; end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:500 + def adjacent?(range1, range2); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:351 + def adjacent_insertion_mask(range); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:366 + def adjacent_insertions?(range); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:347 + def adjacent_position_mask(range); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:377 + def adjacent_updates?(range); end + + # Schedule a code update. If it overlaps with another update, check + # whether they conflict, and raise a clobbering error if they do. + # (As a special case, zero-length ranges at the same position are + # considered to "overlap".) Otherwise, merge them. + # + # Updates which are adjacent to each other, but do not overlap, are also + # merged. + # + # RULES: + # + # - Insertion ("replacing" a zero-length range): + # - Two insertions at the same point conflict. This is true even + # if the earlier insertion has already been merged with an adjacent + # update, and even if they are both inserting the same text. + # - An insertion never conflicts with a replace or remove operation + # on its right or left side, which does not overlap it (in other + # words, which does not update BOTH its right and left sides). + # - An insertion always conflicts with a remove operation which spans + # both its sides. + # - An insertion conflicts with a replace operation which spans both its + # sides, unless the replacement text is longer than the replaced text + # by the size of the insertion (or more), and the portion of + # replacement text immediately after the insertion position is + # identical to the inserted text. + # + # - Removal operations never conflict with each other. + # + # - Replacement operations: + # - Take the portion of each replacement text which falls within: + # - The other operation's replaced region + # - The other operation's replacement text, if it extends past the + # end of its own replaced region (in other words, if the replacement + # text is longer than the text it replaces) + # - If and only if the taken texts are identical for both operations, + # they do not conflict. + # + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:280 + def append(action); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:389 + def can_merge?(action, existing); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:355 + def clobbered_insertion?(insertion); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:343 + def clobbered_position_mask(range); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:468 + def in_transaction?; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:410 + def merge_actions(action, existing); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:419 + def merge_actions!(action, existing); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:425 + def merge_replacements(actions); end + + # @api public + # @raise [ClobberingError] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:450 + def raise_clobber_error(action, existing); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:335 + def record_insertion(range); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:339 + def record_replace(range); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:445 + def replace_actions(old, updated); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/rewriter.rb:383 + def replace_compatible_with_insertion?(replace, insertion); end +end + +# source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:9 +class Parser::Source::Rewriter::Action + include ::Comparable + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:15 + def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:24 + def <=>(other); end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:12 + def allow_multiple_insertions; end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:12 + def allow_multiple_insertions?; end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:12 + def order; end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:12 + def range; end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:12 + def replacement; end + + # source://parser-3.1.2.1/lib/parser/source/rewriter/action.rb:30 + def to_s; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/rewriter.rb:504 +Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +# {TreeRewriter} performs the heavy lifting in the source rewriting process. +# It schedules code updates to be performed in the correct order. +# +# For simple cases, the resulting source will be obvious. +# +# Examples for more complex cases follow. Assume these examples are acting on +# the source `'puts(:hello, :world)`. The methods #wrap, #remove, etc. +# receive a Range as first argument; for clarity, examples below use english +# sentences and a string of raw code instead. +# +# ## Overlapping ranges: +# +# Any two rewriting actions on overlapping ranges will fail and raise +# a `ClobberingError`, unless they are both deletions (covered next). +# +# * wrap ':hello, ' with '(' and ')' +# * wrap ', :world' with '(' and ')' +# => CloberringError +# +# ## Overlapping deletions: +# +# * remove ':hello, ' +# * remove ', :world' +# +# The overlapping ranges are merged and `':hello, :world'` will be removed. +# This policy can be changed. `:crossing_deletions` defaults to `:accept` +# but can be set to `:warn` or `:raise`. +# +# ## Multiple actions at the same end points: +# +# Results will always be independent on the order they were given. +# Exception: rewriting actions done on exactly the same range (covered next). +# +# Example: +# * replace ', ' by ' => ' +# * wrap ':hello, :world' with '{' and '}' +# * replace ':world' with ':everybody' +# * wrap ':world' with '[', ']' +# +# The resulting string will be `'puts({:hello => [:everybody]})'` +# and this result is independent on the order the instructions were given in. +# +# Note that if the two "replace" were given as a single replacement of ', :world' +# for ' => :everybody', the result would be a `ClobberingError` because of the wrap +# in square brackets. +# +# ## Multiple wraps on same range: +# * wrap ':hello' with '(' and ')' +# * wrap ':hello' with '[' and ']' +# +# The wraps are combined in order given and results would be `'puts([(:hello)], :world)'`. +# +# ## Multiple replacements on same range: +# * replace ':hello' by ':hi', then +# * replace ':hello' by ':hey' +# +# The replacements are made in the order given, so the latter replacement +# supersedes the former and ':hello' will be replaced by ':hey'. +# +# This policy can be changed. `:different_replacements` defaults to `:accept` +# but can be set to `:warn` or `:raise`. +# +# ## Swallowed insertions: +# wrap 'world' by '__', '__' +# replace ':hello, :world' with ':hi' +# +# A containing replacement will swallow the contained rewriting actions +# and `':hello, :world'` will be replaced by `':hi'`. +# +# This policy can be changed for swallowed insertions. `:swallowed_insertions` +# defaults to `:accept` but can be set to `:warn` or `:raise` +# +# ## Implementation +# The updates are organized in a tree, according to the ranges they act on +# (where children are strictly contained by their parent), hence the name. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:91 +class Parser::Source::TreeRewriter + extend ::Parser::Deprecation + + # @api public + # @param source_buffer [Source::Buffer] + # @return [TreeRewriter] a new instance of TreeRewriter + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:98 + def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end + + # Returns a representation of the rewriter as nested insertions (:wrap) and replacements. + # + # rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'], + # [:wrap, 2...6, '', '!'], # aka "insert_after" + # [:replace, 2...4, 'foo'], + # [:replace, 5...6, ''], # aka "removal" + # ], + # + # Contrary to `as_replacements`, this representation is sufficient to recreate exactly + # the rewriter. + # + # @api public + # @return [Array<(Symbol, Range, String{, String})>] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:299 + def as_nested_actions; end + + # Returns a representation of the rewriter as an ordered list of replacements. + # + # rewriter.as_replacements # => [ [1...1, '('], + # [2...4, 'foo'], + # [5...6, ''], + # [6...6, '!'], + # [10...10, ')'], + # ] + # + # This representation is sufficient to recreate the result of `process` but it is + # not sufficient to recreate completely the rewriter for further merging/actions. + # See `as_nested_actions` + # + # @api public + # @return [Array] an ordered list of pairs of range & replacement + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:281 + def as_replacements; end + + # @api public + # @return [Diagnostic::Engine] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:93 + def diagnostics; end + + # Returns true iff no (non trivial) update has been recorded + # + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:125 + def empty?; end + + # For special cases where one needs to merge a rewriter attached to a different source_buffer + # or that needs to be offset. Policies of the receiver are used. + # + # @api public + # @param rewriter [TreeRewriter] from different source_buffer + # @param offset [Integer] + # @raise [IndexError] if action ranges (once offset) don't fit the current buffer + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:168 + def import!(foreign_rewriter, offset: T.unsafe(nil)); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:329 + def in_transaction?; end + + # Shortcut for `wrap(range, nil, content)` + # + # @api public + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:242 + def insert_after(range, content); end + + # @api private + # @deprecated Use insert_after or wrap + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:351 + def insert_after_multi(range, text); end + + # Shortcut for `wrap(range, content, nil)` + # + # @api public + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:230 + def insert_before(range, content); end + + # @api private + # @deprecated Use insert_after or wrap + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:342 + def insert_before_multi(range, text); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:334 + def inspect; end + + # Returns a new rewriter that consists of the updates of the received + # and the given argument. Policies of the receiver are used. + # + # @api public + # @param with [Rewriter] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] merge of receiver and argument + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:155 + def merge(with); end + + # Merges the updates of argument with the receiver. + # Policies of the receiver are used. + # This action is atomic in that it won't change the receiver + # unless it succeeds. + # + # @api public + # @param with [Rewriter] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:139 + def merge!(with); end + + # Applies all scheduled changes to the `source_buffer` and returns + # modified source as a new string. + # + # @api public + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:252 + def process; end + + # Shortcut for `replace(range, '')` + # + # @api public + # @param range [Range] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:217 + def remove(range); end + + # Replaces the code of the source range `range` with `content`. + # + # @api public + # @param range [Range] + # @param content [String] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:193 + def replace(range, content); end + + # @api public + # @return [Source::Buffer] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:92 + def source_buffer; end + + # Provides a protected block where a sequence of multiple rewrite actions + # are handled atomically. If any of the actions failed by clobbering, + # all the actions are rolled back. Transactions can be nested. + # + # @api public + # @raise [RuntimeError] when no block is passed + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:310 + def transaction; end + + # Inserts the given strings before and after the given range. + # + # @api public + # @param range [Range] + # @param insert_before [String, nil] + # @param insert_after [String, nil] + # @raise [ClobberingError] when clobbering is detected + # @return [Rewriter] self + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:206 + def wrap(range, insert_before, insert_after); end + + protected + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:365 + def action_root; end + + private + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:369 + def action_summary; end + + # @api public + # @raise [ArgumentError] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:392 + def check_policy_validity; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:404 + def check_range_validity(range); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:397 + def combine(range, attributes); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:411 + def enforce_policy(event); end + + # @api public + # @raise [Parser::ClobberingError] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:418 + def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:391 +Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array) + +# Actions are arranged in a tree and get combined so that: +# children are strictly contained by their parent +# sibblings all disjoint from one another and ordered +# only actions with replacement==nil may have children +# +# @api private +# +# source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:13 +class Parser::Source::TreeRewriter::Action + # @api private + # @return [Action] a new instance of Action + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:16 + def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:28 + def combine(action); end + + # A root action has its range set to the whole source range, even + # though it typically do not act on that range. + # This method returns the action as if it was a child action with + # its range contracted. + # + # @api private + # @return [Action] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:67 + def contract; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:33 + def empty?; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:14 + def insert_after; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:14 + def insert_before; end + + # @api private + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:57 + def insertion?; end + + # No check is done on validity of resulting range. + # + # @api private + # @return [Action] that has been moved to the given source_buffer and with the given offset + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:80 + def moved(source_buffer, offset); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:49 + def nested_actions; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:40 + def ordered_replacements; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:14 + def range; end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:14 + def replacement; end + + protected + + # Returns the children in a hierarchy with respect to `action`: + # :sibbling_left, sibbling_right (for those that are disjoint from `action`) + # :parent (in case one of our children contains `action`) + # :child (in case `action` strictly contains some of our children) + # :fusible (in case `action` overlaps some children but they can be fused in one deletion) + # or raises a `CloberingError` + # In case a child has equal range to `action`, it is returned as `:parent` + # Reminder: an empty range 1...1 is considered disjoint from 1...10 + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:158 + def analyse_hierarchy(action); end + + # Similar to @children.bsearch_index || size + # except allows for a starting point + # and `bsearch_index` is only Ruby 2.3+ + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:145 + def bsearch_child_index(from = T.unsafe(nil)); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:224 + def call_enforcer_for_merge(action); end + + # @api private + # @param fusible [Array(Action | nil)] + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:204 + def check_fusible(action, *fusible); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:94 + def children; end + + # Assumes `more_children` all contained within `@range` + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:129 + def combine_children(more_children); end + + # Assumes range.contains?(action.range) && action.children.empty? + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:102 + def do_combine(action); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:135 + def fuse_deletions(action, fusible, other_sibblings); end + + # Assumes action.range == range && action.children.empty? + # + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:215 + def merge(action); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:110 + def place_in_hierarchy(action); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:232 + def swallow(children); end + + # @api private + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter/action.rb:96 + def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:356 +Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:417 +Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/static_environment.rb:5 +class Parser::StaticEnvironment + # @api public + # @return [StaticEnvironment] a new instance of StaticEnvironment + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:9 + def initialize; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:38 + def declare(name); end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:56 + def declare_anonymous_blockarg; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:48 + def declare_forward_args; end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:44 + def declared?(name); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:60 + def declared_anonymous_blockarg?; end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:52 + def declared_forward_args?; end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:64 + def empty?; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:25 + def extend_dynamic; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:18 + def extend_static; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:13 + def reset; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/static_environment.rb:32 + def unextend; end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/static_environment.rb:7 +Parser::StaticEnvironment::ANONYMOUS_BLOCKARG = T.let(T.unsafe(nil), Symbol) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/static_environment.rb:6 +Parser::StaticEnvironment::FORWARD_ARGS = T.let(T.unsafe(nil), Symbol) + +# {Parser::SyntaxError} is raised whenever parser detects a syntax error, +# similar to the standard SyntaxError class. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/syntax_error.rb:13 +class Parser::SyntaxError < ::StandardError + # @api public + # @return [SyntaxError] a new instance of SyntaxError + # + # source://parser-3.1.2.1/lib/parser/syntax_error.rb:16 + def initialize(diagnostic); end + + # @api public + # @return [Parser::Diagnostic] + # + # source://parser-3.1.2.1/lib/parser/syntax_error.rb:14 + def diagnostic; end +end + +# {Parser::TreeRewriter} offers a basic API that makes it easy to rewrite +# existing ASTs. It's built on top of {Parser::AST::Processor} and +# {Parser::Source::TreeRewriter} +# +# For example, assume you want to remove `do` tokens from a while statement. +# You can do this as following: +# +# require 'parser/current' +# +# class RemoveDo < Parser::TreeRewriter +# def on_while(node) +# # Check if the statement starts with "do" +# if node.location.begin.is?('do') +# remove(node.location.begin) +# end +# end +# end +# +# code = <<-EOF +# while true do +# puts 'hello' +# end +# EOF +# +# ast = Parser::CurrentRuby.parse code +# buffer = Parser::Source::Buffer.new('(example)', source: code) +# rewriter = RemoveDo.new +# +# # Rewrite the AST, returns a String with the new form. +# puts rewriter.rewrite(buffer, ast) +# +# This would result in the following Ruby code: +# +# while true +# puts 'hello' +# end +# +# Keep in mind that {Parser::TreeRewriter} does not take care of indentation when +# inserting/replacing code so you'll have to do this yourself. +# +# See also [a blog entry](http://whitequark.org/blog/2013/04/26/lets-play-with-ruby-code/) +# describing rewriters in greater detail. +# +# @api public +# +# source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:61 +class Parser::TreeRewriter < ::Parser::AST::Processor + # Returns `true` if the specified node is an assignment node, returns false + # otherwise. + # + # @api public + # @param node [Parser::AST::Node] + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:79 + def assignment?(node); end + + # Inserts new code after the given source range. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:118 + def insert_after(range, content); end + + # Inserts new code before the given source range. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:108 + def insert_before(range, content); end + + # Removes the source range. + # + # @api public + # @param range [Parser::Source::Range] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:88 + def remove(range); end + + # Replaces the code of the source range `range` with `content`. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:128 + def replace(range, content); end + + # Rewrites the AST/source buffer and returns a String containing the new + # version. + # + # @api public + # @param source_buffer [Parser::Source::Buffer] + # @param ast [Parser::AST::Node] + # @param crossing_deletions:, [Symbol] different_replacements:, swallowed_insertions: + # policy arguments for TreeRewriter (optional) + # @return [String] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:62 + def rewrite(source_buffer, ast, **policy); end + + # Wraps the given source range with the given values. + # + # @api public + # @param range [Parser::Source::Range] + # @param content [String] + # + # source://parser-3.1.2.1/lib/parser/tree_rewriter.rb:98 + def wrap(range, before, after); end +end + +# @api public +# +# source://parser-3.1.2.1/lib/parser/version.rb:4 +Parser::VERSION = T.let(T.unsafe(nil), String) + +# @api public +# +# source://parser-3.1.2.1/lib/parser/variables_stack.rb:5 +class Parser::VariablesStack + # @api public + # @return [VariablesStack] a new instance of VariablesStack + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:6 + def initialize; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:27 + def declare(name); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:31 + def declared?(name); end + + # @api public + # @return [Boolean] + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:11 + def empty?; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:19 + def pop; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:15 + def push; end + + # @api public + # + # source://parser-3.1.2.1/lib/parser/variables_stack.rb:23 + def reset; end +end diff --git a/sorbet/rbi/gems/pry-byebug.rbi b/sorbet/rbi/gems/pry-byebug.rbi deleted file mode 100644 index 17035b6a..00000000 --- a/sorbet/rbi/gems/pry-byebug.rbi +++ /dev/null @@ -1,155 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry-byebug/all/pry-byebug.rbi -# -# pry-byebug-3.9.0 - -module PryByebug - def check_file_context(target, msg = nil); end - def current_remote_server; end - def current_remote_server=(arg0); end - def file_context?(target); end - def self.check_file_context(target, msg = nil); end - def self.file_context?(target); end -end -module PryByebug::Helpers -end -module PryByebug::Helpers::Location - def current_file(source = nil); end - def self.current_file(source = nil); end -end -module Byebug -end -class Byebug::PryProcessor < Byebug::CommandProcessor - def at_breakpoint(breakpoint); end - def at_end; end - def at_line; end - def at_return(_return_value); end - def bold(*args, &block); end - def n_hits(breakpoint); end - def output(*args, &block); end - def perform(action, options = nil); end - def perform_backtrace(_options); end - def perform_down(options); end - def perform_finish(*arg0); end - def perform_frame(options); end - def perform_next(options); end - def perform_step(options); end - def perform_up(options); end - def pry; end - def pry=(arg0); end - def resume_pry; end - def run(&_block); end - def self.start; end - extend Forwardable -end -class Pry - def self.start_with_pry_byebug(target = nil, options = nil); end - def self.start_without_pry_byebug(target = nil, options = nil); end -end -module PryByebug::Helpers::Navigation - def breakout_navigation(action, options = nil); end -end -class PryByebug::BacktraceCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -module PryByebug::Helpers::Multiline - def check_multiline_context; end -end -class PryByebug::NextCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Multiline - include PryByebug::Helpers::Navigation -end -class PryByebug::StepCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -module PryByebug::Helpers::Breakpoints - def bold_puts(msg); end - def breakpoints; end - def max_width; end - def print_breakpoints_header; end - def print_full_breakpoint(breakpoint); end - def print_short_breakpoint(breakpoint); end -end -class PryByebug::ContinueCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Breakpoints - include PryByebug::Helpers::Location - include PryByebug::Helpers::Navigation -end -class PryByebug::FinishCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -class PryByebug::UpCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -class PryByebug::DownCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -class PryByebug::FrameCommand < Pry::ClassCommand - def process; end - include PryByebug::Helpers::Navigation -end -module Pry::Byebug -end -module Pry::Byebug::Breakpoints - def add_file(file, line, expression = nil); end - def add_method(method, expression = nil); end - def breakpoints; end - def change(id, expression = nil); end - def change_status(id, enabled = nil); end - def delete(id); end - def delete_all; end - def disable(id); end - def disable_all; end - def each(&block); end - def enable(id); end - def find_by_id(id); end - def last; end - def size; end - def to_a; end - def validate_expression(exp); end - extend Enumerable - extend Pry::Byebug::Breakpoints -end -class Pry::Byebug::Breakpoints::FileBreakpoint < SimpleDelegator - def source_code; end - def to_s; end -end -class Pry::Byebug::Breakpoints::MethodBreakpoint < SimpleDelegator - def initialize(byebug_bp, method); end - def source_code; end - def to_s; end -end -class PryByebug::BreakCommand < Pry::ClassCommand - def add_breakpoint(place, condition); end - def new_breakpoint; end - def option_to_method(option); end - def options(opt); end - def print_all; end - def process; end - def process_condition; end - def process_delete; end - def process_delete_all; end - def process_disable; end - def process_disable_all; end - def process_enable; end - def process_show; end - include PryByebug::Helpers::Breakpoints - include PryByebug::Helpers::Location - include PryByebug::Helpers::Multiline -end -class PryByebug::ExitAllCommand < Pry::Command::ExitAll - def process; end -end diff --git a/sorbet/rbi/gems/pry-byebug@3.10.1.rbi b/sorbet/rbi/gems/pry-byebug@3.10.1.rbi new file mode 100644 index 00000000..9d87e364 --- /dev/null +++ b/sorbet/rbi/gems/pry-byebug@3.10.1.rbi @@ -0,0 +1,1735 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `pry-byebug` gem. +# Please instead update this file by running `bin/tapioca gem pry-byebug`. + +# Main Container for all of Byebug's code +# +# source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:5 +module Byebug + extend ::Byebug::Helpers::ReflectionHelper + + # Debugger's display expressions + # + # source://byebug-11.1.3/lib/byebug/core.rb:31 + def displays; end + + # Debugger's display expressions + # + # source://byebug-11.1.3/lib/byebug/core.rb:31 + def displays=(_arg0); end + + # Configuration file used for startup commands. Default value is .byebugrc + # + # source://byebug-11.1.3/lib/byebug/core.rb:25 + def init_file; end + + # Configuration file used for startup commands. Default value is .byebugrc + # + # source://byebug-11.1.3/lib/byebug/core.rb:25 + def init_file=(_arg0); end + + # Running mode of the debugger. Can be either: + # + # * :attached => Attached to a running program through the `byebug` method. + # * :standalone => Started through `byebug` script. + # * :off => Ignoring any `byebug` method calls. + # + # source://byebug-11.1.3/lib/byebug/core.rb:41 + def mode; end + + # Running mode of the debugger. Can be either: + # + # * :attached => Attached to a running program through the `byebug` method. + # * :standalone => Started through `byebug` script. + # * :off => Ignoring any `byebug` method calls. + # + # source://byebug-11.1.3/lib/byebug/core.rb:41 + def mode=(_arg0); end + + # Runs normal byebug initialization scripts. + # + # Reads and executes the commands from init file (if any) in the current + # working directory. This is only done if the current directory is different + # from your home directory. Thus, you can have more than one init file, one + # generic in your home directory, and another, specific to the program you + # are debugging, in the directory where you invoke byebug. + # + # source://byebug-11.1.3/lib/byebug/core.rb:52 + def run_init_script; end + + private + + def add_catchpoint(_arg0); end + def breakpoints; end + def catchpoints; end + def contexts; end + def current_context; end + def debug_load(*_arg0); end + def lock; end + def post_mortem=(_arg0); end + def post_mortem?; end + def raised_exception; end + + # List of folders to load rc files from + # + # @note Files will be loaded in the order specified here. + # + # source://byebug-11.1.3/lib/byebug/core.rb:102 + def rc_dirs; end + + # Runs a initialization script file + # + # source://byebug-11.1.3/lib/byebug/core.rb:91 + def run_rc_file(rc_file); end + + def start; end + def started?; end + def stop; end + def stoppable?; end + def thread_context(_arg0); end + def tracing=(_arg0); end + def tracing?; end + def unlock; end + def verbose=(_arg0); end + def verbose?; end + + class << self + # The actual port that the control server is started at + # + # source://byebug-11.1.3/lib/byebug/remote.rb:25 + def actual_control_port; end + + # The actual port that the server is started at + # + # source://byebug-11.1.3/lib/byebug/remote.rb:20 + def actual_port; end + + def add_catchpoint(_arg0); end + + # Starts byebug, and stops at the first line of user's code. + # + # source://byebug-11.1.3/lib/byebug/attacher.rb:10 + def attach; end + + def breakpoints; end + def catchpoints; end + def contexts; end + def current_context; end + def debug_load(*_arg0); end + + # Saves information about the unhandled exception and gives a byebug + # prompt back to the user before program termination. + # + # source://byebug-11.1.3/lib/byebug/core.rb:76 + def handle_post_mortem; end + + # Interrupts the current thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:32 + def interrupt; end + + # source://byebug-11.1.3/lib/byebug/core.rb:61 + def load_settings; end + + def lock; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:59 + def parse_host_and_port(host_port_spec); end + + def post_mortem=(_arg0); end + def post_mortem?; end + def raised_exception; end + + # source://byebug-11.1.3/lib/byebug/attacher.rb:21 + def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end + + def start; end + + # Connects to the remote byebug + # + # source://byebug-11.1.3/lib/byebug/remote.rb:55 + def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end + + # Starts the remote server control thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:48 + def start_control(host = T.unsafe(nil), port = T.unsafe(nil)); end + + # Starts the remote server main thread + # + # source://byebug-11.1.3/lib/byebug/remote.rb:39 + def start_server(host = T.unsafe(nil), port = T.unsafe(nil)); end + + def started?; end + def stop; end + def stoppable?; end + def thread_context(_arg0); end + def tracing=(_arg0); end + def tracing?; end + def unlock; end + def verbose=(_arg0); end + def verbose?; end + + # If in remote mode, wait for the remote connection + # + # source://byebug-11.1.3/lib/byebug/remote.rb:17 + def wait_connection; end + + # If in remote mode, wait for the remote connection + # + # source://byebug-11.1.3/lib/byebug/remote.rb:17 + def wait_connection=(_arg0); end + + private + + # source://byebug-11.1.3/lib/byebug/remote.rb:66 + def client; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:76 + def control; end + + # source://byebug-11.1.3/lib/byebug/remote.rb:70 + def server; end + end +end + +class Byebug::DebugThread < ::Thread + class << self + def inherited; end + end +end + +# Port number used for remote debugging +# +# source://byebug-11.1.3/lib/byebug/remote.rb:13 +Byebug::PORT = T.let(T.unsafe(nil), Integer) + +# Extends raw byebug's processor. +# +# source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:9 +class Byebug::PryProcessor < ::Byebug::CommandProcessor + # Called when a breakpoint is hit. Note that `at_line`` is called + # inmediately after with the context's `stop_reason == :breakpoint`, so we + # must not resume the pry instance here + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:80 + def at_breakpoint(breakpoint); end + + # Called when the debugger wants to stop at a regular line + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:64 + def at_line; end + + # Called when the debugger wants to stop right before a method return + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:71 + def at_return(_return_value); end + + # source://RUBY_ROOT/forwardable.rb:226 + def bold(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output(*args, &block); end + + # Set up a number of navigational commands to be performed by Byebug. + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:45 + def perform(action, options = T.unsafe(nil)); end + + # Returns the value of attribute pry. + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:10 + def pry; end + + # Sets the attribute pry + # + # @param value the value to set the attribute pry to. + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:10 + def pry=(_arg0); end + + # Wrap a Pry REPL to catch navigational commands and act on them. + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:26 + def run(&_block); end + + private + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:93 + def n_hits(breakpoint); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:114 + def perform_backtrace(_options); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:142 + def perform_down(options); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:130 + def perform_finish(*_arg0); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:150 + def perform_frame(options); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:120 + def perform_next(options); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:125 + def perform_step(options); end + + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:134 + def perform_up(options); end + + # Resume an existing Pry REPL at the paused point. + # + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:102 + def resume_pry; end + + class << self + # source://pry-byebug-3.10.1/lib/byebug/processors/pry_processor.rb:16 + def start; end + end +end + +class Byebug::ThreadsTable; end + +# {Pry::LastException} is a proxy class who wraps an Exception object for +# {Pry#last_exception}. it extends the exception object with methods that +# help pry commands be useful. +# +# the original exception object is not modified and method calls are forwarded +# to the wrapped exception object. +# +# source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:3 +class Pry + extend ::Forwardable + + # Create a new {Pry} instance. + # + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @param options [Hash] + # @return [Pry] a new instance of Pry + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:81 + def initialize(options = T.unsafe(nil)); end + + # Add a sticky local to this Pry instance. + # A sticky local is a local that persists between all bindings in a session. + # + # @param name [Symbol] The name of the sticky local. + # @yield The block that defines the content of the local. The local + # will be refreshed at each tick of the repl loop. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:212 + def add_sticky_local(name, &block); end + + # Returns the value of attribute backtrace. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:35 + def backtrace; end + + # Sets the attribute backtrace + # + # @param value the value to set the attribute backtrace to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:35 + def backtrace=(_arg0); end + + # Returns the value of attribute binding_stack. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:32 + def binding_stack; end + + # Sets the attribute binding_stack + # + # @param value the value to set the attribute binding_stack to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:32 + def binding_stack=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands=(*args, &block); end + + # Generate completions. + # + # @param str [String] What the user has typed so far + # @return [Array] Possible completions + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:145 + def complete(str); end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:50 + def config; end + + # The currently active `Binding`. + # + # @return [Binding] The currently active `Binding` for the session. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:124 + def current_binding; end + + # The currently active `Binding`. + # support previous API + # + # @return [Binding] The currently active `Binding` for the session. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:124 + def current_context; end + + # Returns the value of attribute custom_completions. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:33 + def custom_completions; end + + # Sets the attribute custom_completions + # + # @param value the value to set the attribute custom_completions to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:33 + def custom_completions=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor=(*args, &block); end + + # Pass a line of input to Pry. + # + # This is the equivalent of `Binding#eval` but with extra Pry! + # + # In particular: + # 1. Pry commands will be executed immediately if the line matches. + # 2. Partial lines of input will be queued up until a complete expression has + # been accepted. + # 3. Output is written to `#output` in pretty colours, not returned. + # + # Once this method has raised an exception or returned false, this instance + # is no longer usable. {#exit_value} will return the session's breakout + # value if applicable. + # + # @option options + # @param line [String?] The line of input; `nil` if the user types `` + # @param options [Hash] a customizable set of options + # @raise [Exception] If the user uses the `raise-up` command, this method + # will raise that exception. + # @return [Boolean] Is Pry ready to accept more input? + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:255 + def eval(line, options = T.unsafe(nil)); end + + # Returns the value of attribute eval_string. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:34 + def eval_string; end + + # Sets the attribute eval_string + # + # @param value the value to set the attribute eval_string to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:34 + def eval_string=(_arg0); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:286 + def evaluate_ruby(code); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler=(*args, &block); end + + # Execute the specified hook. + # If executing a hook raises an exception, we log that and then continue sucessfully. + # To debug such errors, use the global variable $pry_hook_error, which is set as a + # result. + # + # @param name [Symbol] The hook name to execute + # @param args [*Object] The arguments to pass to the hook + # @return [Object, Exception] The return value of the hook or the exception raised + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:394 + def exec_hook(name, *args, &block); end + + # Returns the value of attribute exit_value. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:42 + def exit_value; end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks=(*args, &block); end + + # Injects a local variable into the provided binding. + # + # @param name [String] The name of the local to inject. + # @param value [Object] The value to set the local to. + # @param binding [Binding] The binding to set the local on. + # @return [Object] The value the local was set to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:173 + def inject_local(name, value, binding); end + + # Inject all the sticky locals into the current binding. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:201 + def inject_sticky_locals!; end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input=(*args, &block); end + + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:45 + def input_ring; end + + # Returns the value of attribute last_dir. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:39 + def last_dir; end + + # Sets the attribute last_dir + # + # @param value the value to set the attribute last_dir to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:39 + def last_dir=(_arg0); end + + # Returns the value of attribute last_exception. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:41 + def last_exception; end + + # Set the last exception for a session. + # + # @param exception [Exception] The last exception. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:418 + def last_exception=(exception); end + + # Returns the value of attribute last_file. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:38 + def last_file; end + + # Sets the attribute last_file + # + # @param value the value to set the attribute last_file to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:38 + def last_file=(_arg0); end + + # Returns the value of attribute last_result. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:37 + def last_result; end + + # Sets the attribute last_result + # + # @param value the value to set the attribute last_result to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:37 + def last_result=(_arg0); end + + # @return [Boolean] True if the last result is an exception that was raised, + # as opposed to simply an instance of Exception (like the result of + # Exception.new) + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:440 + def last_result_is_exception?; end + + # @return [Integer] The maximum amount of objects remembered by the inp and + # out arrays. Defaults to 100. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:190 + def memory_size; end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:195 + def memory_size=(size); end + + # Returns an output device + # + # @example + # pry_instance.output.puts "ohai!" + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:538 + def output; end + + # source://RUBY_ROOT/forwardable.rb:226 + def output=(*args, &block); end + + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:48 + def output_ring; end + + # Returns the currently configured pager + # + # @example + # pry_instance.pager.page text + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:530 + def pager; end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager=(*args, &block); end + + # Pops the current prompt off of the prompt stack. If the prompt you are + # popping is the last prompt, it will not be popped. Use this to restore the + # previous prompt. + # + # @example + # pry = Pry.new(prompt: Pry::Prompt[:my_prompt1]) + # pry.push_prompt(Pry::Prompt[:my_prompt2]) + # pry.pop_prompt # => prompt2 + # pry.pop_prompt # => prompt1 + # pry.pop_prompt # => prompt1 + # @return [Pry::Prompt] the prompt being popped + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:522 + def pop_prompt; end + + # source://RUBY_ROOT/forwardable.rb:226 + def print(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print=(*args, &block); end + + # If the given line is a valid command, process it in the context of the + # current `eval_string` and binding. + # + # @param val [String] The line to process. + # @return [Boolean] `true` if `val` is a command, `false` otherwise + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:325 + def process_command(val); end + + # Same as process_command, but outputs exceptions to `#output` instead of + # raising. + # + # @param val [String] The line to process. + # @return [Boolean] `true` if `val` is a command, `false` otherwise + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:360 + def process_command_safely(val); end + + # This is the prompt at the top of the prompt stack. + # + # @return [Pry::Prompt] the current prompt + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:101 + def prompt; end + + # Sets the Pry prompt. + # + # @param new_prompt [Pry::Prompt] + # @return [void] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:108 + def prompt=(new_prompt); end + + # Push a binding for the given object onto the stack. If this instance is + # currently stopped, mark it as usable again. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:131 + def push_binding(object); end + + # Initialize this instance by pushing its initial context into the binding + # stack. If no target is given, start at the top level. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:118 + def push_initial_binding(target = T.unsafe(nil)); end + + # Pushes the current prompt onto a stack that it can be restored from later. + # Use this if you wish to temporarily change the prompt. + # + # @example + # push_prompt(Pry::Prompt[:my_prompt]) + # @param new_prompt [Pry::Prompt] + # @return [Pry::Prompt] new_prompt + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:506 + def push_prompt(new_prompt); end + + # Convenience accessor for the `quiet` config key. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:592 + def quiet?; end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:582 + def raise_up(*args); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:586 + def raise_up!(*args); end + + # Raise an exception out of Pry. + # + # See Kernel#raise for documentation of parameters. + # See rb_make_exception for the inbuilt implementation. + # + # This is necessary so that the raise-up command can tell the + # difference between an exception the user has decided to raise, + # and a mistake in specifying that exception. + # + # (i.e. raise-up RunThymeError.new should not be the same as + # raise-up NameError, "unititialized constant RunThymeError") + # + # @raise [TypeError] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:554 + def raise_up_common(force, *args); end + + # Potentially deprecated. Use `Pry::REPL.new(pry, :target => target).start` + # (If nested sessions are going to exist, this method is fine, but a goal is + # to come up with an alternative to nested sessions altogether.) + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:282 + def repl(target = T.unsafe(nil)); end + + # Reset the current eval string. If the user has entered part of a multiline + # expression, this discards that input. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:231 + def reset_eval_string; end + + # Run the specified command. + # + # @example + # pry_instance.run_command("ls -m") + # @param val [String] The command (and its params) to execute. + # @return [Pry::Command::VOID_VALUE] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:375 + def run_command(val); end + + # Returns the appropriate prompt to use. + # + # @return [String] The prompt. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:453 + def select_prompt; end + + # Set the last result of an eval. + # This method should not need to be invoked directly. + # + # @param result [Object] The result. + # @param code [String] The code that was run. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:409 + def set_last_result(result, code = T.unsafe(nil)); end + + # Whether the print proc should be invoked. + # Currently only invoked if the output is not suppressed. + # + # @return [Boolean] Whether the print proc should be invoked. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:447 + def should_print?; end + + # Output the result or pass to an exception handler (if result is an exception). + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:298 + def show_result(result); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:216 + def sticky_locals; end + + # Returns the value of attribute suppress_output. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:36 + def suppress_output; end + + # Sets the attribute suppress_output + # + # @param value the value to set the attribute suppress_output to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:36 + def suppress_output=(_arg0); end + + # Update Pry's internal state after evalling code. + # This method should not need to be invoked directly. + # + # @param code [String] The code we just eval'd + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:428 + def update_input_history(code); end + + private + + # Force `eval_string` into the encoding of `val`. [Issue #284] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:680 + def ensure_correct_encoding!(val); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:688 + def generate_prompt(prompt_proc, conf); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:598 + def handle_line(line, options); end + + # the array that the prompt stack is stored in + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:697 + def prompt_stack; end + + class << self + # Convert the given object into an instance of `Pry::Code`, if it isn't + # already one. + # + # @param obj [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array, IO] + # + # source://pry-0.14.1/lib/pry/code.rb:12 + def Code(obj); end + + # If the given object is a `Pry::Method`, return it unaltered. If it's + # anything else, return it wrapped in a `Pry::Method` instance. + # + # source://pry-0.14.1/lib/pry/method.rb:9 + def Method(obj); end + + # If the given object is a `Pry::WrappedModule`, return it unaltered. If it's + # anything else, return it wrapped in a `Pry::WrappedModule` instance. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:7 + def WrappedModule(obj); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:288 + def auto_resize!; end + + # Return a `Binding` object for `target` or return `target` if it is + # already a `Binding`. + # In the case where `target` is top-level then return `TOPLEVEL_BINDING` + # + # @param target [Object] The object to get a `Binding` object for. + # @return [Binding] The `Binding` object. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:341 + def binding_for(target); end + + # Returns the value of attribute cli. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:22 + def cli; end + + # Sets the attribute cli + # + # @param value the value to set the attribute cli to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:22 + def cli=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands=(*args, &block); end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:25 + def config; end + + # Sets the attribute config + # + # @param value the value to set the attribute config to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:25 + def config=(_arg0); end + + # @example + # Pry.configure do |config| + # config.eager_load! # optional + # config.input = # .. + # config.foo = 2 + # end + # @yield [config] Yields a block with {Pry.config} as its argument. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:46 + def configure; end + + # source://pry-0.14.1/lib/pry/pry_class.rb:374 + def critical_section; end + + # @return [Pry::Config] Returns a value store for an instance of Pry running on the current thread. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:63 + def current; end + + # Returns the value of attribute current_line. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:19 + def current_line; end + + # Sets the attribute current_line + # + # @param value the value to set the attribute current_line to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:19 + def current_line=(_arg0); end + + # Returns the value of attribute custom_completions. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:18 + def custom_completions; end + + # Sets the attribute custom_completions + # + # @param value the value to set the attribute custom_completions to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:18 + def custom_completions=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor=(*args, &block); end + + # Returns the value of attribute eval_path. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:21 + def eval_path; end + + # Sets the attribute eval_path + # + # @param value the value to set the attribute eval_path to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:21 + def eval_path=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals=(*args, &block); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:139 + def final_session_setup; end + + # source://RUBY_ROOT/forwardable.rb:226 + def history(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def history=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks=(*args, &block); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:369 + def in_critical_section?; end + + # Basic initialization. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:332 + def init; end + + # @return [Boolean] Whether this is the first time a Pry session has + # been started since loading the Pry class. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:251 + def initial_session?; end + + # Do basic setup for initial session including: loading pryrc, plugins, + # requires, and history. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:129 + def initial_session_setup; end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input=(*args, &block); end + + # Returns the value of attribute last_internal_error. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:24 + def last_internal_error; end + + # Sets the attribute last_internal_error + # + # @param value the value to set the attribute last_internal_error to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:24 + def last_internal_error=(_arg0); end + + # Returns the value of attribute line_buffer. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:20 + def line_buffer; end + + # Sets the attribute line_buffer + # + # @param value the value to set the attribute line_buffer to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:20 + def line_buffer=(_arg0); end + + # Load the given file in the context of `Pry.toplevel_binding` + # + # @param file [String] The unexpanded file path. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:69 + def load_file_at_toplevel(file); end + + # Execute the file through the REPL loop, non-interactively. + # + # @param file_name [String] File name to load through the REPL. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:196 + def load_file_through_repl(file_name); end + + # Load Readline history if required. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:245 + def load_history; end + + # Load RC files if appropriate This method can also be used to reload the + # files if they have changed. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:77 + def load_rc_files; end + + # Load any Ruby files specified with the -r flag on the command line. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:101 + def load_requires; end + + # Trap interrupts on jruby, and make them behave like MRI so we can + # catch them. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:109 + def load_traps; end + + # source://pry-0.14.1/lib/pry/pry_class.rb:113 + def load_win32console; end + + # @return [main] returns the special instance of Object, "main". + # + # source://pry-0.14.1/lib/pry/pry_class.rb:55 + def main; end + + # source://RUBY_ROOT/forwardable.rb:226 + def memory_size(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def memory_size=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prompt(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prompt=(*args, &block); end + + # Returns the value of attribute quiet. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:23 + def quiet; end + + # Sets the attribute quiet + # + # @param value the value to set the attribute quiet to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:23 + def quiet=(_arg0); end + + # Load the local RC file (./.pryrc) + # + # source://pry-0.14.1/lib/pry/pry_class.rb:86 + def rc_files_to_load; end + + # Expand a file to its canonical name (following symlinks as appropriate) + # + # source://pry-0.14.1/lib/pry/pry_class.rb:94 + def real_path_to(file); end + + # Set all the configurable options back to their default values + # + # source://pry-0.14.1/lib/pry/pry_class.rb:320 + def reset_defaults; end + + # Run a Pry command from outside a session. The commands available are + # those referenced by `Pry.config.commands` (the default command set). + # + # @example Run under Pry class, returning only public methods. + # Pry.run_command "ls -m", :target => Pry + # @example Run at top-level with no output. + # Pry.run_command "ls" + # @example Display command output. + # Pry.run_command "ls -av", :show_output => true + # @option options + # @option options + # @param command_string [String] The Pry command (including arguments, + # if any). + # @param options [Hash] Optional named parameters. + # @return [nil] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:271 + def run_command(command_string, options = T.unsafe(nil)); end + + # Start a Pry REPL. + # This method also loads `pryrc` as necessary the first time it is invoked. + # + # @example + # Pry.start(Object.new, :input => MyInput.new) + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @param target [Object, Binding] The receiver of the Pry session + # @param options [Hash] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:156 + def start(target = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:348 + def toplevel_binding; end + + # Sets the attribute toplevel_binding + # + # @param value the value to set the attribute toplevel_binding to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:366 + def toplevel_binding=(_arg0); end + + # An inspector that clips the output to `max_length` chars. + # In case of > `max_length` chars the `# notation is used. + # + # @option options + # @option options + # @param obj [Object] The object to view. + # @param options [Hash] + # @return [String] The string representation of `obj`. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:219 + def view_clip(obj, options = T.unsafe(nil)); end + end +end + +# @return [Array] Code of the method used when implementing Pry's +# __binding__, along with line indication to be used with instance_eval (and +# friends). +# @see Object#__binding__ +# +# source://pry-0.14.1/lib/pry/core_extensions.rb:9 +Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array) + +# source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:4 +module Pry::Byebug; end + +# Wrapper for Byebug.breakpoints that respects our Processor and has better +# failure behavior. Acts as an Enumerable. +# +# source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:9 +module Pry::Byebug::Breakpoints + extend ::Enumerable + extend ::Pry::Byebug::Breakpoints + + # Adds a file breakpoint. + # + # @raise [ArgumentError] + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:63 + def add_file(file, line, expression = T.unsafe(nil)); end + + # Adds a method breakpoint. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:51 + def add_method(method, expression = T.unsafe(nil)); end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:44 + def breakpoints; end + + # Changes the conditional expression for a breakpoint. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:78 + def change(id, expression = T.unsafe(nil)); end + + # Deletes an existing breakpoint with the given ID. + # + # @raise [ArgumentError] + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:89 + def delete(id); end + + # Deletes all breakpoints. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:100 + def delete_all; end + + # Disables a breakpoint with the given ID. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:115 + def disable(id); end + + # Disables all breakpoints. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:122 + def disable_all; end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:136 + def each(&block); end + + # Enables a disabled breakpoint with the given ID. + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:108 + def enable(id); end + + # @raise [ArgumentError] + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:144 + def find_by_id(id); end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:140 + def last; end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:132 + def size; end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:128 + def to_a; end + + private + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:153 + def change_status(id, enabled = T.unsafe(nil)); end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:159 + def validate_expression(exp); end +end + +# Breakpoint in a file:line location +# +# source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:16 +class Pry::Byebug::Breakpoints::FileBreakpoint < ::SimpleDelegator + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:17 + def source_code; end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:21 + def to_s; end +end + +# Breakpoint in a Class#method location +# +# source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:29 +class Pry::Byebug::Breakpoints::MethodBreakpoint < ::SimpleDelegator + # @return [MethodBreakpoint] a new instance of MethodBreakpoint + # + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:30 + def initialize(byebug_bp, method); end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:35 + def source_code; end + + # source://pry-byebug-3.10.1/lib/pry/byebug/breakpoints.rb:39 + def to_s; end +end + +# source://pry-0.14.1/lib/pry.rb:35 +Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet) + +# source://pry-0.14.1/lib/pry/pry_instance.rb:59 +Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/pry_class.rb:7 +Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String) + +class Pry::REPL + extend ::Forwardable + + # Create an instance of {REPL} wrapping the given {Pry}. + # + # @option options + # @param pry [Pry] The instance of {Pry} that this {REPL} will control. + # @param options [Hash] Options for this {REPL} instance. + # @return [REPL] a new instance of REPL + # + # source://pry-0.14.1/lib/pry/repl.rb:22 + def initialize(pry, options = T.unsafe(nil)); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output(*args, &block); end + + # @return [Pry] The instance of {Pry} that the user is controlling. + # + # source://pry-0.14.1/lib/pry/repl.rb:9 + def pry; end + + # @return [Pry] The instance of {Pry} that the user is controlling. + # + # source://pry-0.14.1/lib/pry/repl.rb:9 + def pry=(_arg0); end + + # Start the read-eval-print loop. + # + # @raise [Exception] If the session throws `:raise_up`, raise the exception + # thrown with it. + # @return [Object?] If the session throws `:breakout`, return the value + # thrown with it. + # + # source://pry-0.14.1/lib/pry/repl.rb:36 + def start; end + + private + + # Calculates correct overhang for current line. Supports vi Readline + # mode and its indicators such as "(ins)" or "(cmd)". + # + # @note This doesn't calculate overhang for Readline's emacs mode with an + # indicator because emacs is the default mode and it doesn't use + # indicators in 99% of cases. + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/repl.rb:238 + def calculate_overhang(current_prompt, original_val, indented_val); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:206 + def coolline_available?; end + + # Clean up after the repl session. + # + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:84 + def epilogue; end + + # Manage switching of input objects on encountering `EOFError`s. + # + # @return [Object] Whatever the given block returns. + # @return [:no_more_input] Indicates that no more input can be read. + # + # source://pry-0.14.1/lib/pry/repl.rb:127 + def handle_read_errors; end + + # source://pry-0.14.1/lib/pry/repl.rb:196 + def input_readline(*args); end + + # If `$stdout` is not a tty, it's probably a pipe. + # + # @example + # # `piping?` returns `false` + # % pry + # [1] pry(main) + # + # # `piping?` returns `true` + # % pry | tee log + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:218 + def piping?; end + + # Set up the repl session. + # + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:47 + def prologue; end + + # Read a line of input from the user. + # + # @return [String] The line entered by the user. + # @return [nil] On ``. + # @return [:control_c] On ``. + # @return [:no_more_input] On EOF. + # + # source://pry-0.14.1/lib/pry/repl.rb:93 + def read; end + + # Returns the next line of input to be sent to the {Pry} instance. + # + # @param current_prompt [String] The prompt to use for input. + # @return [String?] The next line of input, or `nil` on . + # + # source://pry-0.14.1/lib/pry/repl.rb:170 + def read_line(current_prompt); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:202 + def readline_available?; end + + # The actual read-eval-print loop. + # + # The {REPL} instance is responsible for reading and looping, whereas the + # {Pry} instance is responsible for evaluating user input and printing + # return values and command output. + # + # @raise [Exception] If the session throws `:raise_up`, raise the exception + # thrown with it. + # @return [Object?] If the session throws `:breakout`, return the value + # thrown with it. + # + # source://pry-0.14.1/lib/pry/repl.rb:66 + def repl; end + + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:225 + def set_readline_output; end + + class << self + # source://pry-byebug-3.10.1/lib/pry-byebug/pry_ext.rb:8 + def start(options = T.unsafe(nil)); end + + # source://pry-byebug-3.10.1/lib/pry-byebug/pry_ext.rb:8 + def start_with_pry_byebug(options = T.unsafe(nil)); end + + # Instantiate a new {Pry} instance with the given options, then start a + # {REPL} instance wrapping it. + # + # @option options + # @param options [Hash] a customizable set of options + # + # source://pry-0.14.1/lib/pry/repl.rb:14 + def start_without_pry_byebug(options); end + end +end + +# source://pry-0.14.1/lib/pry/version.rb:4 +Pry::VERSION = T.let(T.unsafe(nil), String) + +# Main container module for Pry-Byebug functionality +# +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/location.rb:3 +module PryByebug + # Reference to currently running pry-remote server. Used by the processor. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:10 + def current_remote_server; end + + # Reference to currently running pry-remote server. Used by the processor. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:10 + def current_remote_server=(_arg0); end + + private + + # Ensures that a command is executed in a local file context. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:25 + def check_file_context(target, msg = T.unsafe(nil)); end + + # Checks that a target binding is in a local file context. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:17 + def file_context?(target); end + + class << self + # Ensures that a command is executed in a local file context. + # + # @raise [Pry::CommandError] + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:25 + def check_file_context(target, msg = T.unsafe(nil)); end + + # Checks that a target binding is in a local file context. + # + # @return [Boolean] + # + # source://pry-byebug-3.10.1/lib/pry-byebug/base.rb:17 + def file_context?(target); end + end +end + +# Display the current stack +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/backtrace.rb:9 +class PryByebug::BacktraceCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/backtrace.rb:23 + def process; end +end + +# Add, show and remove breakpoints +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:12 +class PryByebug::BreakCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Breakpoints + include ::PryByebug::Helpers::Location + include ::PryByebug::Helpers::Multiline + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:50 + def options(opt); end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:62 + def process; end + + private + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:111 + def add_breakpoint(place, condition); end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:93 + def new_breakpoint; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:102 + def option_to_method(option); end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:106 + def print_all; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:88 + def process_condition; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:78 + def process_delete; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:78 + def process_delete_all; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:78 + def process_disable; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:78 + def process_disable_all; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:78 + def process_enable; end + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/breakpoint.rb:84 + def process_show; end +end + +# Continue program execution until the next breakpoint +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/continue.rb:11 +class PryByebug::ContinueCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + include ::PryByebug::Helpers::Breakpoints + include ::PryByebug::Helpers::Location + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/continue.rb:31 + def process; end +end + +# Travel down the frame stack +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/down.rb:9 +class PryByebug::DownCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/down.rb:27 + def process; end +end + +# Exit pry REPL with Byebug.stop +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/exit_all.rb:9 +class PryByebug::ExitAllCommand < ::Pry::Command::ExitAll + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/exit_all.rb:10 + def process; end +end + +# Run until the end of current frame +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/finish.rb:9 +class PryByebug::FinishCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/finish.rb:20 + def process; end +end + +# Move to a specific frame in the callstack +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/frame.rb:9 +class PryByebug::FrameCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/frame.rb:27 + def process; end +end + +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/location.rb:4 +module PryByebug::Helpers; end + +# Common helpers for breakpoint related commands +# +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:10 +module PryByebug::Helpers::Breakpoints + # Prints a message with bold font. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:21 + def bold_puts(msg); end + + # Byebug's array of breakpoints. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:14 + def breakpoints; end + + # Max width of breakpoints id column + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:77 + def max_width; end + + # Prints a header for the breakpoint list. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:63 + def print_breakpoints_header; end + + # Print out full information about a breakpoint. + # + # Includes surrounding code at that point. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:30 + def print_full_breakpoint(breakpoint); end + + # Print out concise information about a breakpoint. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/breakpoints.rb:52 + def print_short_breakpoint(breakpoint); end +end + +# Compatibility helper to handle source location +# +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/location.rb:8 +module PryByebug::Helpers::Location + private + + # Current file in the target binding. Used as the default breakpoint + # location. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/location.rb:15 + def current_file(source = T.unsafe(nil)); end + + class << self + # Current file in the target binding. Used as the default breakpoint + # location. + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/location.rb:15 + def current_file(source = T.unsafe(nil)); end + end +end + +# Helpers to help handling multiline inputs +# +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/multiline.rb:8 +module PryByebug::Helpers::Multiline + # Returns true if we are in a multiline context and, as a side effect, + # updates the partial evaluation string with the current input. + # + # Returns false otherwise + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/multiline.rb:15 + def check_multiline_context; end +end + +# Helpers to aid breaking out of the REPL loop +# +# source://pry-byebug-3.10.1/lib/pry-byebug/helpers/navigation.rb:8 +module PryByebug::Helpers::Navigation + # Breaks out of the REPL loop and signals tracer + # + # source://pry-byebug-3.10.1/lib/pry-byebug/helpers/navigation.rb:12 + def breakout_navigation(action, options = T.unsafe(nil)); end +end + +# Run a number of lines and then stop again +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/next.rb:10 +class PryByebug::NextCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + include ::PryByebug::Helpers::Multiline + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/next.rb:29 + def process; end +end + +# Run a number of Ruby statements and then stop again +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/step.rb:9 +class PryByebug::StepCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/step.rb:26 + def process; end +end + +# Travel up the frame stack +# +# source://pry-byebug-3.10.1/lib/pry-byebug/commands/up.rb:9 +class PryByebug::UpCommand < ::Pry::ClassCommand + include ::PryByebug::Helpers::Navigation + + # source://pry-byebug-3.10.1/lib/pry-byebug/commands/up.rb:27 + def process; end +end diff --git a/sorbet/rbi/gems/pry.rbi b/sorbet/rbi/gems/pry.rbi deleted file mode 100644 index 43728e80..00000000 --- a/sorbet/rbi/gems/pry.rbi +++ /dev/null @@ -1,1949 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/pry/all/pry.rbi -# -# pry-0.13.1 - -class Pry - def add_sticky_local(name, &block); end - def backtrace; end - def backtrace=(arg0); end - def binding_stack; end - def binding_stack=(arg0); end - def color(*args, &block); end - def color=(*args, &block); end - def commands(*args, &block); end - def commands=(*args, &block); end - def complete(str); end - def config; end - def current_binding; end - def current_context; end - def custom_completions; end - def custom_completions=(arg0); end - def editor(*args, &block); end - def editor=(*args, &block); end - def ensure_correct_encoding!(val); end - def eval(line, options = nil); end - def eval_string; end - def eval_string=(arg0); end - def evaluate_ruby(code); end - def exception_handler(*args, &block); end - def exception_handler=(*args, &block); end - def exec_hook(name, *args, &block); end - def exit_value; end - def extra_sticky_locals(*args, &block); end - def extra_sticky_locals=(*args, &block); end - def generate_prompt(prompt_proc, conf); end - def handle_line(line, options); end - def hooks(*args, &block); end - def hooks=(*args, &block); end - def initialize(options = nil); end - def inject_local(name, value, binding); end - def inject_sticky_locals!; end - def input(*args, &block); end - def input=(*args, &block); end - def input_ring; end - def last_dir; end - def last_dir=(arg0); end - def last_exception; end - def last_exception=(exception); end - def last_file; end - def last_file=(arg0); end - def last_result; end - def last_result=(arg0); end - def last_result_is_exception?; end - def memory_size; end - def memory_size=(size); end - def output; end - def output=(*args, &block); end - def output_ring; end - def pager; end - def pager=(*args, &block); end - def pop_prompt; end - def print(*args, &block); end - def print=(*args, &block); end - def process_command(val); end - def process_command_safely(val); end - def prompt; end - def prompt=(new_prompt); end - def prompt_stack; end - def push_binding(object); end - def push_initial_binding(target = nil); end - def push_prompt(new_prompt); end - def quiet?; end - def raise_up!(*args); end - def raise_up(*args); end - def raise_up_common(force, *args); end - def repl(target = nil); end - def reset_eval_string; end - def run_command(val); end - def select_prompt; end - def self.Code(obj); end - def self.Method(obj); end - def self.WrappedModule(obj); end - def self.auto_resize!; end - def self.binding_for(target); end - def self.cli; end - def self.cli=(arg0); end - def self.color(*args, &block); end - def self.color=(*args, &block); end - def self.commands(*args, &block); end - def self.commands=(*args, &block); end - def self.config; end - def self.config=(arg0); end - def self.configure; end - def self.critical_section; end - def self.current; end - def self.current_line; end - def self.current_line=(arg0); end - def self.custom_completions; end - def self.custom_completions=(arg0); end - def self.editor(*args, &block); end - def self.editor=(*args, &block); end - def self.eval_path; end - def self.eval_path=(arg0); end - def self.exception_handler(*args, &block); end - def self.exception_handler=(*args, &block); end - def self.extra_sticky_locals(*args, &block); end - def self.extra_sticky_locals=(*args, &block); end - def self.final_session_setup; end - def self.history(*args, &block); end - def self.history=(*args, &block); end - def self.hooks(*args, &block); end - def self.hooks=(*args, &block); end - def self.in_critical_section?; end - def self.init; end - def self.initial_session?; end - def self.initial_session_setup; end - def self.input(*args, &block); end - def self.input=(*args, &block); end - def self.last_internal_error; end - def self.last_internal_error=(arg0); end - def self.line_buffer; end - def self.line_buffer=(arg0); end - def self.load_file_at_toplevel(file); end - def self.load_file_through_repl(file_name); end - def self.load_history; end - def self.load_plugins(*args, &block); end - def self.load_rc_files; end - def self.load_requires; end - def self.load_traps; end - def self.load_win32console; end - def self.locate_plugins(*args, &block); end - def self.main; end - def self.memory_size(*args, &block); end - def self.memory_size=(*args, &block); end - def self.output(*args, &block); end - def self.output=(*args, &block); end - def self.pager(*args, &block); end - def self.pager=(*args, &block); end - def self.plugins(*args, &block); end - def self.print(*args, &block); end - def self.print=(*args, &block); end - def self.prompt(*args, &block); end - def self.prompt=(*args, &block); end - def self.quiet; end - def self.quiet=(arg0); end - def self.rc_files_to_load; end - def self.real_path_to(file); end - def self.reset_defaults; end - def self.run_command(command_string, options = nil); end - def self.start(target = nil, options = nil); end - def self.toplevel_binding; end - def self.toplevel_binding=(arg0); end - def self.view_clip(obj, options = nil); end - def set_last_result(result, code = nil); end - def should_print?; end - def show_result(result); end - def sticky_locals; end - def suppress_output; end - def suppress_output=(arg0); end - def update_input_history(code); end - extend Pry::Forwardable -end -class Pry::LastException < BasicObject - def bt_index; end - def bt_index=(arg0); end - def bt_source_location_for(index); end - def file; end - def inc_bt_index; end - def initialize(exception); end - def line; end - def method_missing(name, *args, &block); end - def respond_to_missing?(name, include_all = nil); end - def wrapped_exception; end -end -module Pry::Forwardable - def def_private_delegators(target, *private_delegates); end - include Forwardable -end -module Pry::Helpers - def self.tablify(things, line_length, pry_instance = nil); end - def self.tablify_or_one_line(heading, things, pry_instance = nil); end - def self.tablify_to_screen_width(things, options, pry_instance = nil); end -end -module Pry::Helpers::BaseHelpers - def colorize_code(code); end - def find_command(name, set = nil); end - def heading(text); end - def highlight(string, regexp, highlight_color = nil); end - def not_a_real_file?(file); end - def safe_send(obj, method, *args, &block); end - def silence_warnings; end - def stagger_output(text, _out = nil); end - def use_ansi_codes?; end - extend Pry::Helpers::BaseHelpers -end -module Pry::Helpers::DocumentationHelpers - def get_comment_content(comment); end - def process_comment_markup(comment); end - def process_rdoc(comment); end - def process_yardoc(comment); end - def process_yardoc_tag(comment, tag); end - def self.get_comment_content(comment); end - def self.process_comment_markup(comment); end - def self.process_rdoc(comment); end - def self.process_yardoc(comment); end - def self.process_yardoc_tag(comment, tag); end - def self.strip_comments_from_c_code(code); end - def self.strip_leading_whitespace(text); end - def strip_comments_from_c_code(code); end - def strip_leading_whitespace(text); end -end -module Pry::Helpers::OptionsHelpers - def method_object; end - def method_options(opt); end - def self.method_object; end - def self.method_options(opt); end -end -module Pry::Helpers::CommandHelpers - def absolute_index_number(line_number, array_length); end - def absolute_index_range(range_or_number, array_length); end - def get_method_or_raise(method_name, context, opts = nil); end - def internal_binding?(context); end - def one_index_number(line_number); end - def one_index_range(range); end - def one_index_range_or_number(range_or_number); end - def restrict_to_lines(content, lines); end - def set_file_and_dir_locals(file_name, pry = nil, ctx = nil); end - def temp_file(ext = nil); end - def unindent(dirty_text, left_padding = nil); end - extend Pry::Helpers::CommandHelpers - include Pry::Helpers::OptionsHelpers -end -module Pry::Helpers::Text - def black(text); end - def black_on_black(text); end - def black_on_blue(text); end - def black_on_cyan(text); end - def black_on_green(text); end - def black_on_magenta(text); end - def black_on_purple(text); end - def black_on_red(text); end - def black_on_white(text); end - def black_on_yellow(text); end - def blue(text); end - def blue_on_black(text); end - def blue_on_blue(text); end - def blue_on_cyan(text); end - def blue_on_green(text); end - def blue_on_magenta(text); end - def blue_on_purple(text); end - def blue_on_red(text); end - def blue_on_white(text); end - def blue_on_yellow(text); end - def bold(text); end - def bright_black(text); end - def bright_black_on_black(text); end - def bright_black_on_blue(text); end - def bright_black_on_cyan(text); end - def bright_black_on_green(text); end - def bright_black_on_magenta(text); end - def bright_black_on_purple(text); end - def bright_black_on_red(text); end - def bright_black_on_white(text); end - def bright_black_on_yellow(text); end - def bright_blue(text); end - def bright_blue_on_black(text); end - def bright_blue_on_blue(text); end - def bright_blue_on_cyan(text); end - def bright_blue_on_green(text); end - def bright_blue_on_magenta(text); end - def bright_blue_on_purple(text); end - def bright_blue_on_red(text); end - def bright_blue_on_white(text); end - def bright_blue_on_yellow(text); end - def bright_cyan(text); end - def bright_cyan_on_black(text); end - def bright_cyan_on_blue(text); end - def bright_cyan_on_cyan(text); end - def bright_cyan_on_green(text); end - def bright_cyan_on_magenta(text); end - def bright_cyan_on_purple(text); end - def bright_cyan_on_red(text); end - def bright_cyan_on_white(text); end - def bright_cyan_on_yellow(text); end - def bright_green(text); end - def bright_green_on_black(text); end - def bright_green_on_blue(text); end - def bright_green_on_cyan(text); end - def bright_green_on_green(text); end - def bright_green_on_magenta(text); end - def bright_green_on_purple(text); end - def bright_green_on_red(text); end - def bright_green_on_white(text); end - def bright_green_on_yellow(text); end - def bright_magenta(text); end - def bright_magenta_on_black(text); end - def bright_magenta_on_blue(text); end - def bright_magenta_on_cyan(text); end - def bright_magenta_on_green(text); end - def bright_magenta_on_magenta(text); end - def bright_magenta_on_purple(text); end - def bright_magenta_on_red(text); end - def bright_magenta_on_white(text); end - def bright_magenta_on_yellow(text); end - def bright_purple(text); end - def bright_purple_on_black(text); end - def bright_purple_on_blue(text); end - def bright_purple_on_cyan(text); end - def bright_purple_on_green(text); end - def bright_purple_on_magenta(text); end - def bright_purple_on_purple(text); end - def bright_purple_on_red(text); end - def bright_purple_on_white(text); end - def bright_purple_on_yellow(text); end - def bright_red(text); end - def bright_red_on_black(text); end - def bright_red_on_blue(text); end - def bright_red_on_cyan(text); end - def bright_red_on_green(text); end - def bright_red_on_magenta(text); end - def bright_red_on_purple(text); end - def bright_red_on_red(text); end - def bright_red_on_white(text); end - def bright_red_on_yellow(text); end - def bright_white(text); end - def bright_white_on_black(text); end - def bright_white_on_blue(text); end - def bright_white_on_cyan(text); end - def bright_white_on_green(text); end - def bright_white_on_magenta(text); end - def bright_white_on_purple(text); end - def bright_white_on_red(text); end - def bright_white_on_white(text); end - def bright_white_on_yellow(text); end - def bright_yellow(text); end - def bright_yellow_on_black(text); end - def bright_yellow_on_blue(text); end - def bright_yellow_on_cyan(text); end - def bright_yellow_on_green(text); end - def bright_yellow_on_magenta(text); end - def bright_yellow_on_purple(text); end - def bright_yellow_on_red(text); end - def bright_yellow_on_white(text); end - def bright_yellow_on_yellow(text); end - def cyan(text); end - def cyan_on_black(text); end - def cyan_on_blue(text); end - def cyan_on_cyan(text); end - def cyan_on_green(text); end - def cyan_on_magenta(text); end - def cyan_on_purple(text); end - def cyan_on_red(text); end - def cyan_on_white(text); end - def cyan_on_yellow(text); end - def default(text); end - def green(text); end - def green_on_black(text); end - def green_on_blue(text); end - def green_on_cyan(text); end - def green_on_green(text); end - def green_on_magenta(text); end - def green_on_purple(text); end - def green_on_red(text); end - def green_on_white(text); end - def green_on_yellow(text); end - def indent(text, chars); end - def magenta(text); end - def magenta_on_black(text); end - def magenta_on_blue(text); end - def magenta_on_cyan(text); end - def magenta_on_green(text); end - def magenta_on_magenta(text); end - def magenta_on_purple(text); end - def magenta_on_red(text); end - def magenta_on_white(text); end - def magenta_on_yellow(text); end - def no_color; end - def no_pager; end - def purple(text); end - def purple_on_black(text); end - def purple_on_blue(text); end - def purple_on_cyan(text); end - def purple_on_green(text); end - def purple_on_magenta(text); end - def purple_on_purple(text); end - def purple_on_red(text); end - def purple_on_white(text); end - def purple_on_yellow(text); end - def red(text); end - def red_on_black(text); end - def red_on_blue(text); end - def red_on_cyan(text); end - def red_on_green(text); end - def red_on_magenta(text); end - def red_on_purple(text); end - def red_on_red(text); end - def red_on_white(text); end - def red_on_yellow(text); end - def strip_color(text); end - def white(text); end - def white_on_black(text); end - def white_on_blue(text); end - def white_on_cyan(text); end - def white_on_green(text); end - def white_on_magenta(text); end - def white_on_purple(text); end - def white_on_red(text); end - def white_on_white(text); end - def white_on_yellow(text); end - def with_line_numbers(text, offset, color = nil); end - def yellow(text); end - def yellow_on_black(text); end - def yellow_on_blue(text); end - def yellow_on_cyan(text); end - def yellow_on_green(text); end - def yellow_on_magenta(text); end - def yellow_on_purple(text); end - def yellow_on_red(text); end - def yellow_on_white(text); end - def yellow_on_yellow(text); end - extend Pry::Helpers::Text -end -class Pry::Helpers::Table - def ==(other); end - def _max_width(things); end - def _rebuild_colorless_cache; end - def _recall_color_for(thing); end - def _recolumn; end - def column_count; end - def column_count=(count); end - def columns; end - def fits_on_line?(line_length); end - def initialize(items, args, pry_instance = nil); end - def items; end - def items=(items); end - def rows_to_s(style = nil); end - def to_a; end - def to_s; end -end -module Pry::Helpers::Platform - def self.jruby?; end - def self.jruby_19?; end - def self.linux?; end - def self.mac_osx?; end - def self.mri?; end - def self.mri_19?; end - def self.mri_2?; end - def self.windows?; end - def self.windows_ansi?; end -end -class Pry::BasicObject < BasicObject - include Kernel -end -class Pry::Prompt - def [](key); end - def description; end - def incomplete_proc; end - def initialize(name, description, prompt_procs); end - def name; end - def prompt_procs; end - def self.[](name); end - def self.add(name, description = nil, separators = nil); end - def self.all; end - def wait_proc; end -end -class Pry::PluginManager - def gem_list; end - def initialize; end - def load_plugins; end - def locate_plugins; end - def plugin_located?(plugin); end - def plugins; end -end -class Pry::PluginManager::NoPlugin - def initialize(name); end - def method_missing(*arg0); end - def respond_to_missing?(*arg0); end -end -class Pry::PluginManager::Plugin - def activate!; end - def active; end - def active=(arg0); end - def active?; end - def disable!; end - def enable!; end - def enabled; end - def enabled=(arg0); end - def enabled?; end - def gem_name; end - def gem_name=(arg0); end - def initialize(name, gem_name, spec, enabled); end - def load_cli_options; end - def name; end - def name=(arg0); end - def spec; end - def spec=(arg0); end - def supported?; end -end -class Pry::CodeObject - def command_lookup; end - def default_lookup; end - def empty_lookup; end - def initialize(str, pry_instance, options = nil); end - def looks_like_an_instance_method?(str); end - def lookup_super(obj, super_level); end - def method_or_class_lookup; end - def pry_instance; end - def pry_instance=(arg0); end - def safe_to_evaluate?(str); end - def self.lookup(str, pry_instance, options = nil); end - def sourcable_object?(obj); end - def str; end - def str=(arg0); end - def super_level; end - def super_level=(arg0); end - def target; end - def target=(arg0); end - def target_self; end - include Pry::Helpers::CommandHelpers -end -module Pry::CodeObject::Helpers - def c_method?; end - def c_module?; end - def command?; end - def module_with_yard_docs?; end - def real_method_object?; end -end -module Pry::RescuableException - def self.===(exception); end -end -module Pry::TooSafeException - def self.===(exception); end -end -module Pry::UserError -end -module Pry::FrozenObjectException - def self.===(exception); end -end -class Pry::CommandError < StandardError -end -class Pry::MethodNotFound < Pry::CommandError -end -class Pry::ObsoleteError < StandardError -end -class Pry::Hooks - def add_hook(event_name, hook_name, callable = nil, &block); end - def clear_event_hooks(event_name); end - def delete_hook(event_name, hook_name); end - def errors; end - def exec_hook(event_name, *args, &block); end - def get_hook(event_name, hook_name); end - def get_hooks(event_name); end - def hook_count(event_name); end - def hook_exists?(event_name, hook_name); end - def hooks; end - def initialize; end - def initialize_copy(_orig); end - def merge!(other); end - def merge(other); end - def self.default; end -end -class Pry::InputCompleter - def build_path(input); end - def call(str, options = nil); end - def ignored_modules; end - def initialize(input, pry = nil); end - def select_message(path, receiver, message, candidates); end -end -class Pry::Command - def _pry_; end - def _pry_=(arg0); end - def after_hooks; end - def arg_string; end - def arg_string=(arg0); end - def before_hooks; end - def block; end - def call_safely(*args); end - def call_with_hooks(*args); end - def captures; end - def captures=(arg0); end - def check_for_command_collision(command_match, arg_string); end - def command_block; end - def command_block=(arg0); end - def command_name; end - def command_options; end - def command_set; end - def command_set=(arg0); end - def commands; end - def complete(_search); end - def context; end - def context=(arg0); end - def description; end - def eval_string; end - def eval_string=(arg0); end - def find_hooks(event); end - def hooks; end - def hooks=(arg0); end - def initialize(context = nil); end - def interpolate_string(str); end - def match; end - def name; end - def normalize_method_args(method, args); end - def output; end - def output=(arg0); end - def pass_block(arg_string); end - def process_line(line); end - def pry_instance; end - def pry_instance=(arg0); end - def run(command_string, *args); end - def self.banner(arg = nil); end - def self.block; end - def self.block=(arg0); end - def self.command_name; end - def self.command_options(arg = nil); end - def self.command_options=(arg0); end - def self.command_regex; end - def self.convert_to_regex(obj); end - def self.default_options(match); end - def self.description(arg = nil); end - def self.description=(arg0); end - def self.doc; end - def self.file; end - def self.group(name = nil); end - def self.inspect; end - def self.line; end - def self.match(arg = nil); end - def self.match=(arg0); end - def self.match_score(val); end - def self.matches?(val); end - def self.name; end - def self.options(arg = nil); end - def self.options=(arg0); end - def self.source; end - def self.source_file; end - def self.source_line; end - def self.state; end - def self.subclass(match, description, options, helpers, &block); end - def source; end - def state; end - def target; end - def target=(arg0); end - def target_self; end - def tokenize(val); end - def use_unpatched_symbol; end - def void; end - extend Pry::CodeObject::Helpers - extend Pry::Helpers::DocumentationHelpers - include Pry::Helpers::BaseHelpers - include Pry::Helpers::CommandHelpers - include Pry::Helpers::Text -end -class Pry::ClassCommand < Pry::Command - def args; end - def args=(arg0); end - def call(*args); end - def complete(search); end - def help; end - def options(opt); end - def opts; end - def opts=(arg0); end - def process; end - def self.doc; end - def self.file; end - def self.inherited(klass); end - def self.line; end - def self.source; end - def self.source_file; end - def self.source_line; end - def self.source_location; end - def self.source_object; end - def setup; end - def slop; end - def subcommands(cmd); end -end -class Pry::BlockCommand < Pry::Command - def call(*args); end - def help; end -end -class Pry::NoCommandError < StandardError - def initialize(match, owner); end -end -class Pry::CommandSet - def [](pattern); end - def []=(pattern, command); end - def add_command(command); end - def alias_command(match, action, options = nil); end - def block_command(match, description = nil, options = nil, &block); end - def command(match, description = nil, options = nil, &block); end - def complete(search, context = nil); end - def create_command(match, description = nil, options = nil, &block); end - def delete(*searches); end - def desc(search, description = nil); end - def each(&block); end - def find_command(pattern); end - def find_command_by_match_or_listing(match_or_listing); end - def find_command_for_help(search); end - def helper_module; end - def helpers(&block); end - def import(*sets); end - def import_from(set, *matches); end - def initialize(*imported_sets, &block); end - def keys; end - def list_commands; end - def process_line(val, context = nil); end - def rename_command(new_match, search, options = nil); end - def to_h; end - def to_hash; end - def valid_command?(val); end - include Enumerable - include Pry::Helpers::BaseHelpers -end -class Pry::Result - def command?; end - def initialize(is_command, retval = nil); end - def retval; end - def void_command?; end -end -class Pry::SyntaxHighlighter - def self.highlight(code, language = nil); end - def self.keyword_token_color; end - def self.overwrite_coderay_comment_token!; end - def self.tokenize(code, language = nil); end -end -class Pry::Editor - def blocking_flag_for_editor(blocking); end - def build_editor_invocation_string(file, line, blocking); end - def edit_tempfile_with_content(initial_content, line = nil); end - def editor_name; end - def initialize(pry_instance); end - def invoke_editor(file, line, blocking = nil); end - def open_editor(editor_invocation); end - def open_editor_on_jruby(editor_invocation); end - def pry_instance; end - def self.default; end - def start_line_syntax_for_editor(file_name, line_number); end - include Pry::Helpers::CommandHelpers -end -class Pry::History - def <<(line); end - def clear; end - def filter(history); end - def history_file; end - def history_file_path; end - def history_line_count; end - def initialize(options = nil); end - def invalid_readline_line?(line); end - def load; end - def loader; end - def loader=(arg0); end - def original_lines; end - def push(line); end - def read_from_file; end - def save_to_file(line); end - def saver; end - def saver=(arg0); end - def self.default_file; end - def session_line_count; end - def should_ignore?(line); end - def to_a; end -end -class Pry::ColorPrinter < PP - def highlight_object_literal(object_literal); end - def inspect_object(object); end - def pp(object); end - def self.default(_output, value, pry_instance); end - def self.pp(obj, output = nil, max_width = nil); end - def text(str, max_width = nil); end -end -module Pry::ExceptionHandler - def self.cause_text(cause); end - def self.exception_text(exception); end - def self.handle_exception(output, exception, _pry_instance); end - def self.standard_error_text_for(exception); end -end -module Pry::SystemCommandHandler - def self.default(output, command, _pry_instance); end -end -module Pry::ControlDHandler - def self.default(pry_instance); end -end -class Pry::CommandState - def initialize; end - def reset(command_name); end - def self.default; end - def state_for(command_name); end -end -module Pry::Warning - def self.warn(message); end -end -module Pry::Env - def self.[](key); end -end -class Pry::Command::Ls < Pry::ClassCommand - def error_list; end - def no_user_opts?; end - def options(opt); end - def process; end - def raise_errors_if_arguments_are_weird; end -end -module Pry::Command::Ls::JRubyHacks - def rubbishness(name); end - def trim_jruby_aliases(methods); end -end -module Pry::Command::Ls::MethodsHelper - def all_methods(instance_methods = nil); end - def format(methods); end - def resolution_order; end - include Pry::Command::Ls::JRubyHacks -end -module Pry::Command::Ls::Interrogatable - def interrogatee_mod; end - def interrogating_a_module?; end -end -class Pry::Command::Ls::Grep - def initialize(grep_regexp); end - def regexp; end -end -class Pry::Command::Ls::Formatter - def color(type, str); end - def correct_opts?; end - def format_value(value); end - def grep; end - def grep=(arg0); end - def initialize(pry_instance); end - def output_section(heading, body); end - def output_self; end - def pry_instance; end - def write_out; end -end -class Pry::Command::Ls::Globals < Pry::Command::Ls::Formatter - def format(globals); end - def initialize(opts, pry_instance); end - def output_self; end -end -class Pry::Command::Ls::Constants < Pry::Command::Ls::Formatter - def correct_opts?; end - def format(mod, constants); end - def initialize(interrogatee, no_user_opts, opts, pry_instance); end - def output_self; end - def show_deprecated_constants?; end - include Pry::Command::Ls::Interrogatable -end -class Pry::Command::Ls::Methods < Pry::Command::Ls::Formatter - def below_ceiling; end - def correct_opts?; end - def initialize(interrogatee, no_user_opts, opts, pry_instance); end - def output_self; end - include Pry::Command::Ls::Interrogatable - include Pry::Command::Ls::MethodsHelper -end -class Pry::Command::Ls::SelfMethods < Pry::Command::Ls::Formatter - def correct_opts?; end - def initialize(interrogatee, no_user_opts, opts, pry_instance); end - def output_self; end - include Pry::Command::Ls::Interrogatable - include Pry::Command::Ls::MethodsHelper -end -class Pry::Command::Ls::InstanceVars < Pry::Command::Ls::Formatter - def correct_opts?; end - def format(type, vars); end - def initialize(interrogatee, no_user_opts, opts, pry_instance); end - def output_self; end - include Pry::Command::Ls::Interrogatable -end -class Pry::Command::Ls::LocalNames < Pry::Command::Ls::Formatter - def correct_opts?; end - def format(locals); end - def initialize(no_user_opts, args, pry_instance); end - def output_self; end -end -class Pry::Command::Ls::LocalVars < Pry::Command::Ls::Formatter - def colorized_assignment_style(lhs, rhs, desired_width = nil); end - def format(name_value_pairs); end - def initialize(opts, pry_instance); end - def output_self; end -end -class Pry::Command::Ls::LsEntity - def constants; end - def entities; end - def entities_table; end - def globals; end - def grep(entity); end - def initialize(opts); end - def instance_vars; end - def local_names; end - def local_vars; end - def methods; end - def pry_instance; end - def self_methods; end -end -class Pry::Config - def [](attr); end - def []=(attr, value); end - def auto_indent; end - def auto_indent=(arg0); end - def collision_warning; end - def collision_warning=(arg0); end - def color; end - def color=(arg0); end - def command_completions; end - def command_completions=(arg0); end - def command_prefix; end - def command_prefix=(arg0); end - def commands; end - def commands=(arg0); end - def completer; end - def completer=(arg0); end - def control_d_handler; end - def control_d_handler=(value); end - def correct_indent; end - def correct_indent=(arg0); end - def default_rc_file; end - def default_window_size; end - def default_window_size=(arg0); end - def disable_auto_reload; end - def disable_auto_reload=(arg0); end - def editor; end - def editor=(arg0); end - def exception_handler; end - def exception_handler=(arg0); end - def exception_whitelist; end - def exception_whitelist=(arg0); end - def exec_string; end - def exec_string=(arg0); end - def extra_sticky_locals; end - def extra_sticky_locals=(arg0); end - def file_completions; end - def file_completions=(arg0); end - def history; end - def history=(arg0); end - def history_file; end - def history_file=(arg0); end - def history_ignorelist; end - def history_ignorelist=(arg0); end - def history_load; end - def history_load=(arg0); end - def history_save; end - def history_save=(arg0); end - def hooks; end - def hooks=(arg0); end - def initialize; end - def initialize_dup(other); end - def input; end - def input=(arg0); end - def lazy_readline; end - def ls; end - def ls=(arg0); end - def memory_size; end - def memory_size=(arg0); end - def merge!(config_hash); end - def merge(config_hash); end - def method_missing(method_name, *args, &_block); end - def output; end - def output=(arg0); end - def output_prefix; end - def output_prefix=(arg0); end - def pager; end - def pager=(arg0); end - def print; end - def print=(arg0); end - def prompt; end - def prompt=(arg0); end - def prompt_name; end - def prompt_name=(arg0); end - def prompt_safe_contexts; end - def prompt_safe_contexts=(arg0); end - def quiet; end - def quiet=(arg0); end - def rc_file; end - def rc_file=(arg0); end - def requires; end - def requires=(arg0); end - def respond_to_missing?(method_name, include_all = nil); end - def should_load_local_rc; end - def should_load_local_rc=(arg0); end - def should_load_plugins; end - def should_load_plugins=(arg0); end - def should_load_rc; end - def should_load_rc=(arg0); end - def should_load_requires; end - def should_load_requires=(arg0); end - def should_trap_interrupts; end - def should_trap_interrupts=(arg0); end - def system; end - def system=(arg0); end - def unrescued_exceptions; end - def unrescued_exceptions=(arg0); end - def windows_console_warning; end - def windows_console_warning=(arg0); end - extend Pry::Config::Attributable -end -module Pry::Config::Attributable - def attribute(attr_name); end -end -class Pry::Config::Value - def call; end - def initialize(value); end -end -class Pry::Config::MemoizedValue - def call; end - def initialize(&block); end -end -class Pry::Config::LazyValue - def call; end - def initialize(&block); end -end -class Pry::Inspector -end -class Pry::Pager - def best_available; end - def enabled?; end - def initialize(pry_instance); end - def open; end - def output; end - def page(text); end - def pry_instance; end -end -class Pry::Pager::StopPaging < StandardError -end -class Pry::Pager::NullPager - def <<(str); end - def close; end - def height; end - def initialize(out); end - def print(str); end - def puts(str); end - def width; end - def write(str); end -end -class Pry::Pager::SimplePager < Pry::Pager::NullPager - def initialize(*arg0); end - def write(str); end -end -class Pry::Pager::SystemPager < Pry::Pager::NullPager - def close; end - def initialize(*arg0); end - def invoked_pager?; end - def pager; end - def self.available?; end - def self.default_pager; end - def write(str); end - def write_to_pager(text); end -end -class Pry::Pager::PageTracker - def initialize(rows, cols); end - def line_length(line); end - def page?; end - def record(str); end - def reset; end -end -class Pry::Indent - def correct_indentation(prompt, code, overhang = nil); end - def current_prefix; end - def end_of_statement?(last_token, last_kind); end - def in_string?; end - def indent(input); end - def indent_level; end - def indentation_delta(tokens); end - def initialize(pry_instance = nil); end - def module_nesting; end - def open_delimiters; end - def open_delimiters_line; end - def reset; end - def self.indent(str); end - def self.nesting_at(str, line_number); end - def stack; end - def tokenize(string); end - def track_delimiter(token); end - def track_module_nesting(token, kind); end - def track_module_nesting_end(token, kind = nil); end - include Pry::Helpers::BaseHelpers -end -class Pry::Indent::UnparseableNestingError < StandardError -end -class Pry::ObjectPath - def complete?(segment); end - def handle_failure(context, err); end - def initialize(path_string, current_stack); end - def resolve; end -end -class Pry::Output - def <<(*objs); end - def actual_screen_size; end - def ansicon_env_size; end - def decolorize_maybe(str); end - def env_size; end - def height; end - def initialize(pry_instance); end - def io_console_size; end - def method_missing(method_name, *args, &block); end - def nonzero_column?(size); end - def print(*objs); end - def pry_instance; end - def puts(*objs); end - def readline_size; end - def respond_to_missing?(method_name, include_private = nil); end - def size; end - def tty?; end - def width; end - def write(*objs); end -end -class Pry::InputLock - def __with_ownership; end - def enter_interruptible_region; end - def initialize; end - def interruptible_region; end - def leave_interruptible_region; end - def self.for(input); end - def self.global_lock; end - def self.global_lock=(arg0); end - def self.input_locks; end - def self.input_locks=(arg0); end - def with_ownership(&block); end -end -class Pry::InputLock::Interrupt < Exception -end -class Pry::REPL - def calculate_overhang(current_prompt, original_val, indented_val); end - def coolline_available?; end - def epilogue; end - def handle_read_errors; end - def initialize(pry, options = nil); end - def input(*args, &block); end - def input_readline(*args); end - def output(*args, &block); end - def piping?; end - def prologue; end - def pry; end - def pry=(arg0); end - def read; end - def read_line(current_prompt); end - def readline_available?; end - def repl; end - def self.start(options); end - def set_readline_output; end - def start; end - extend Pry::Forwardable -end -class Pry::Code - def <<(line); end - def ==(other); end - def after(lineno, lines = nil); end - def alter(&block); end - def around(lineno, lines = nil); end - def before(lineno, lines = nil); end - def between(start_line, end_line = nil); end - def code_type; end - def code_type=(arg0); end - def comment_describing(line_number); end - def expression_at(line_number, consume = nil); end - def grep(pattern); end - def highlighted; end - def initialize(lines = nil, start_line = nil, code_type = nil); end - def length; end - def max_lineno_width; end - def method_missing(method_name, *args, &block); end - def nesting_at(line_number); end - def print_to_output(output, color = nil); end - def push(line); end - def raw; end - def reject(&block); end - def respond_to_missing?(method_name, include_private = nil); end - def select(&block); end - def self.from_file(filename, code_type = nil); end - def self.from_method(meth, start_line = nil); end - def self.from_module(mod, candidate_rank = nil, start_line = nil); end - def take_lines(start_line, num_lines); end - def to_s; end - def with_indentation(spaces = nil); end - def with_line_numbers(y_n = nil); end - def with_marker(lineno = nil); end -end -class Pry::Ring - def <<(value); end - def [](index); end - def clear; end - def count; end - def initialize(max_size); end - def max_size; end - def size; end - def to_a; end - def transpose_buffer_tail; end -end -class Pry::Method - def ==(other); end - def alias?; end - def aliases; end - def bound_method?; end - def c_source; end - def comment; end - def doc; end - def dynamically_defined?; end - def initialize(method, known_info = nil); end - def is_a?(klass); end - def kind_of?(klass); end - def method_missing(method_name, *args, &block); end - def method_name_from_first_line(first_ln); end - def name; end - def name_with_owner; end - def original_name; end - def owner(*args, &block); end - def parameters(*args, &block); end - def pry_doc_info; end - def pry_method?; end - def receiver(*args, &block); end - def redefine(source); end - def respond_to?(method_name, include_all = nil); end - def respond_to_missing?(method_name, include_private = nil); end - def ruby_source; end - def self.all_from_class(klass, include_super = nil); end - def self.all_from_obj(obj, include_super = nil); end - def self.from_binding(binding); end - def self.from_class(klass, name, target = nil); end - def self.from_module(klass, name, target = nil); end - def self.from_obj(obj, name, target = nil); end - def self.from_str(name, target = nil, options = nil); end - def self.instance_method_definition?(name, definition_line); end - def self.instance_resolution_order(klass); end - def self.lookup_method_via_binding(obj, method_name, method_type, target = nil); end - def self.method_definition?(name, definition_line); end - def self.resolution_order(obj); end - def self.singleton_class_of(obj); end - def self.singleton_class_resolution_order(klass); end - def self.singleton_method_definition?(name, definition_line); end - def signature; end - def singleton_method?; end - def source; end - def source?; end - def source_file; end - def source_line; end - def source_range; end - def source_type; end - def super(times = nil); end - def super_using_ancestors(ancestors, times = nil); end - def unbound_method?; end - def undefined?; end - def visibility; end - def wrapped; end - def wrapped_owner; end - extend Pry::Forwardable - extend Pry::Helpers::BaseHelpers - include Pry::CodeObject::Helpers - include Pry::Helpers::BaseHelpers - include Pry::Helpers::DocumentationHelpers -end -class Pry::WrappedModule - def all_methods_for(mod); end - def all_relevant_methods_for(mod); end - def all_source_locations_by_popularity; end - def candidate(rank); end - def candidates; end - def class?; end - def constants(inherit = nil); end - def doc; end - def file; end - def initialize(mod); end - def line; end - def lines_for_file(file); end - def method_candidates; end - def method_defined_by_forwardable_module?(method); end - def method_missing(method_name, *args, &block); end - def method_prefix; end - def module?; end - def nested_module?(parent, name); end - def nonblank_name; end - def number_of_candidates; end - def primary_candidate; end - def respond_to_missing?(method_name, include_private = nil); end - def self.from_str(mod_name, target = nil); end - def self.safe_to_evaluate?(str, target); end - def singleton_class?; end - def singleton_instance; end - def source; end - def source_file; end - def source_line; end - def source_location; end - def super(times = nil); end - def wrapped; end - def yard_doc; end - def yard_docs?; end - def yard_file; end - def yard_line; end - include Pry::CodeObject::Helpers - include Pry::Helpers::BaseHelpers -end -class Pry::WrappedModule::Candidate - def class?(*args, &block); end - def class_regexes; end - def doc; end - def file; end - def first_line_of_module_definition(file, line); end - def first_method_source_location; end - def initialize(wrapper, rank); end - def last_method_source_location; end - def line; end - def lines_for_file(*a, &b); end - def method_candidates(*a, &b); end - def module?(*args, &block); end - def name(*a, &b); end - def nonblank_name(*args, &block); end - def number_of_candidates(*args, &block); end - def number_of_lines_in_first_chunk; end - def source; end - def source_file; end - def source_line; end - def source_location; end - def wrapped(*args, &block); end - def yard_docs?(*a, &b); end - extend Pry::Forwardable - include Pry::CodeObject::Helpers - include Pry::Helpers::DocumentationHelpers -end -class Pry::Slop - def [](key); end - def add_callback(label, &block); end - def autocreate(items, index); end - def banner(banner = nil); end - def banner=(banner); end - def build_option(objects, &block); end - def clean(object); end - def command(command, options = nil, &block); end - def commands_to_help; end - def config; end - def description(desc = nil); end - def description=(desc); end - def each(&block); end - def execute_multiple_switches(option, argument, index); end - def execute_option(option, argument, index, item = nil); end - def extract_long_flag(objects, config); end - def extract_option(flag); end - def extract_short_flag(objects, config); end - def fetch_command(command); end - def fetch_option(key); end - def get(key); end - def help; end - def initialize(config = nil, &block); end - def method_missing(method, *args, &block); end - def missing; end - def on(*objects, &block); end - def opt(*objects, &block); end - def option(*objects, &block); end - def options; end - def parse!(items = nil, &block); end - def parse(items = nil, &block); end - def present?(*keys); end - def process_item(items, index, &block); end - def respond_to_missing?(method_name, include_all = nil); end - def run(callable = nil, &block); end - def self.optspec(string, config = nil); end - def self.parse!(items = nil, config = nil, &block); end - def self.parse(items = nil, config = nil, &block); end - def separator(text); end - def strict?; end - def to_h(include_commands = nil); end - def to_hash(include_commands = nil); end - def to_s; end - include Enumerable -end -class Pry::Slop::Option - def accepts_optional_argument?; end - def argument?; end - def argument_in_value; end - def argument_in_value=(arg0); end - def as?; end - def autocreated?; end - def call(*objects); end - def callback?; end - def config; end - def count; end - def count=(arg0); end - def default?; end - def delimiter?; end - def description; end - def expects_argument?; end - def help; end - def initialize(slop, short, long, description, config = nil, &block); end - def inspect; end - def key; end - def limit?; end - def long; end - def match?; end - def optional?; end - def optional_argument?; end - def required?; end - def short; end - def tail?; end - def to_s; end - def types; end - def value; end - def value=(new_value); end - def value_to_float(value); end - def value_to_integer(value); end - def value_to_range(value); end -end -class Pry::Slop::Commands - def [](key); end - def arguments; end - def banner(banner = nil); end - def banner=(arg0); end - def commands; end - def config; end - def default(config = nil, &block); end - def each(&block); end - def execute_arguments!(items); end - def execute_global_opts!(items); end - def get(key); end - def global(config = nil, &block); end - def help; end - def initialize(config = nil, &block); end - def inspect; end - def on(command, config = nil, &block); end - def parse!(items = nil); end - def parse(items = nil); end - def present?(key); end - def to_hash; end - def to_s; end - include Enumerable -end -class Pry::Slop::Error < StandardError -end -class Pry::Slop::MissingArgumentError < Pry::Slop::Error -end -class Pry::Slop::MissingOptionError < Pry::Slop::Error -end -class Pry::Slop::InvalidArgumentError < Pry::Slop::Error -end -class Pry::Slop::InvalidOptionError < Pry::Slop::Error -end -class Pry::Slop::InvalidCommandError < Pry::Slop::Error -end -class Pry::Command::ExitAll < Pry::ClassCommand - def process; end -end -class Pry::CLI - def self.add_option_processor(&block); end - def self.add_options(&block); end - def self.add_plugin_options; end - def self.input_args; end - def self.input_args=(arg0); end - def self.option_processors; end - def self.option_processors=(arg0); end - def self.options; end - def self.options=(arg0); end - def self.parse_options(args = nil); end - def self.reset; end - def self.start(opts); end -end -class Pry::CLI::NoOptionsError < StandardError -end -class Object < BasicObject - def __binding__; end - def pry(object = nil, hash = nil); end -end -class BasicObject - def __binding__; end -end -class Pry::REPLFileLoader - def define_additional_commands; end - def initialize(file_name); end - def interactive_mode(pry_instance); end - def load; end - def non_interactive_mode(pry_instance, content); end -end -class Pry::Code::LOC - def ==(other); end - def add_line_number(max_width = nil, color = nil); end - def add_marker(marker_lineno); end - def colorize(code_type); end - def dup; end - def handle_multiline_entries_from_edit_command(line, max_width); end - def indent(distance); end - def initialize(line, lineno); end - def line; end - def lineno; end - def tuple; end -end -class Pry::Code::CodeRange - def end_line; end - def find_end_index(lines); end - def find_start_index(lines); end - def force_set_end_line; end - def indices(lines); end - def indices_range(lines); end - def initialize(start_line, end_line = nil); end - def set_end_line_from_range; end - def start_line; end -end -class Pry::CodeFile - def abs_path; end - def code; end - def code_path; end - def code_type; end - def from_load_path; end - def from_pry_init_pwd; end - def from_pwd; end - def initialize(filename, code_type = nil); end - def readable?(path); end - def type_from_filename(filename, default = nil); end -end -class Pry::Method::WeirdMethodLocator - def all_methods_for(obj); end - def expanded_source_location(source_location); end - def find_method; end - def find_method_in_superclass; end - def find_renamed_method; end - def index_to_line_number(index); end - def initialize(method, target); end - def lines_for_file(file); end - def lost_method?; end - def method; end - def method=(arg0); end - def normal_method?(method); end - def pry_file?; end - def renamed_method_source_location; end - def self.normal_method?(method, binding); end - def self.weird_method?(method, binding); end - def skip_superclass_search?; end - def target; end - def target=(arg0); end - def target_file; end - def target_line; end - def target_self; end - def valid_file?(file); end -end -class Pry::Method::Disowned < Pry::Method - def initialize(receiver, method_name); end - def method_missing(method_name, *args, &block); end - def name; end - def owner; end - def receiver; end - def respond_to_missing?(method_name, include_private = nil); end - def source?; end - def undefined?; end -end -class Pry::Method::Patcher - def cache_key; end - def definition_for_owner(line); end - def initialize(method); end - def method; end - def method=(arg0); end - def patch_in_ram(source); end - def redefine(source); end - def self.code_for(filename); end - def with_method_transaction; end - def wrap(source); end - def wrap_for_nesting(source); end - def wrap_for_owner(source); end -end -class Pry::Command::AmendLine < Pry::ClassCommand - def amend_input; end - def delete_from_array(array, range); end - def insert_into_array(array, range); end - def line_count; end - def line_range; end - def process; end - def replace_in_array(array, range); end - def start_and_end_line_number; end - def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end -end -class Pry::Command::Bang < Pry::ClassCommand - def process; end -end -class Pry::Command::BangPry < Pry::ClassCommand - def process; end -end -class Pry::Command::Cat < Pry::ClassCommand - def complete(search); end - def load_path_completions; end - def options(opt); end - def process; end -end -class Pry::Command::Cat::AbstractFormatter - def between_lines; end - def code_type; end - def decorate(content); end - def use_line_numbers?; end - include Pry::Helpers::BaseHelpers - include Pry::Helpers::CommandHelpers -end -class Pry::Command::Cat::InputExpressionFormatter < Pry::Command::Cat::AbstractFormatter - def format; end - def initialize(input_expressions, opts); end - def input_expressions; end - def input_expressions=(arg0); end - def normalized_expression_range; end - def numbered_input_items; end - def opts; end - def opts=(arg0); end - def selected_input_items; end -end -class Pry::Command::Cat::ExceptionFormatter < Pry::Command::Cat::AbstractFormatter - def backtrace_file; end - def backtrace_level; end - def backtrace_line; end - def check_for_errors; end - def code_window_size; end - def ex; end - def format; end - def header; end - def increment_backtrace_level; end - def initialize(exception, pry_instance, opts); end - def opts; end - def pry_instance; end - def start_and_end_line_for_code_window; end - include Pry::Helpers::Text -end -class Pry::Command::Cat::FileFormatter < Pry::Command::Cat::AbstractFormatter - def code_type; end - def code_window_size; end - def decorate(content); end - def detect_code_type_from_file(file_name); end - def file_and_line; end - def file_name; end - def file_with_embedded_line; end - def format; end - def initialize(file_with_embedded_line, pry_instance, opts); end - def line_number; end - def opts; end - def pry_instance; end -end -class Pry::Command::Cd < Pry::ClassCommand - def process; end -end -class Pry::Command::ChangeInspector < Pry::ClassCommand - def inspector_map; end - def process(inspector); end -end -class Pry::Command::ChangePrompt < Pry::ClassCommand - def change_prompt(prompt); end - def list_prompts; end - def options(opt); end - def process(prompt); end -end -class Pry::Command::ClearScreen < Pry::ClassCommand - def process; end -end -class Pry::Command::CodeCollector - def args; end - def bad_option_combination?; end - def code_object; end - def code_object_doc; end - def code_object_source_or_file; end - def content; end - def convert_to_range(range); end - def could_not_locate(name); end - def file; end - def file=(arg0); end - def file_content; end - def initialize(args, opts, pry_instance); end - def line_range; end - def obj_name; end - def opts; end - def pry_array_content_as_string(array, ranges); end - def pry_input_content; end - def pry_instance; end - def pry_output_content; end - def restrict_to_lines(content, range); end - def self.inject_options(opt); end - def self.input_expression_ranges; end - def self.input_expression_ranges=(arg0); end - def self.output_result_ranges; end - def self.output_result_ranges=(arg0); end - include Pry::Helpers::CommandHelpers -end -class Pry::Command::DisablePry < Pry::ClassCommand - def process; end -end -class Pry::Command::Edit < Pry::ClassCommand - def apply_runtime_patch; end - def bad_option_combination?; end - def code_object; end - def ensure_file_name_is_valid(file_name); end - def file_and_line; end - def file_and_line_for_current_exception; end - def file_based_exception?; end - def file_edit; end - def filename_argument; end - def initial_temp_file_content; end - def input_expression; end - def never_reload?; end - def options(opt); end - def patch_exception?; end - def previously_patched?(code_object); end - def probably_a_file?(str); end - def process; end - def pry_method?(code_object); end - def reload?(file_name = nil); end - def reloadable?; end - def repl_edit; end - def repl_edit?; end - def runtime_patch?; end -end -class Pry::Command::Edit::ExceptionPatcher - def file_and_line; end - def file_and_line=(arg0); end - def initialize(pry_instance, state, exception_file_and_line); end - def perform_patch; end - def pry_instance; end - def pry_instance=(arg0); end - def state; end - def state=(arg0); end -end -module Pry::Command::Edit::FileAndLineLocator - def self.from_binding(target); end - def self.from_code_object(code_object, filename_argument); end - def self.from_exception(exception, backtrace_level); end - def self.from_filename_argument(filename_argument); end -end -class Pry::Command::Exit < Pry::ClassCommand - def process; end - def process_pop_and_return; end -end -class Pry::Command::ExitProgram < Pry::ClassCommand - def process; end -end -class Pry::Command::FindMethod < Pry::ClassCommand - def additional_info(header, method); end - def content_search(namespace); end - def matched_method_lines(header, method); end - def name_search(namespace); end - def options(opt); end - def pattern; end - def print_matches(matches); end - def print_matches_for_class(klass, grouped); end - def process; end - def recurse_namespace(klass, done = nil, &block); end - def search_all_methods(namespace); end - def search_class; end - def show_search_results(matches); end - extend Pry::Helpers::BaseHelpers -end -class Pry::Command::FixIndent < Pry::ClassCommand - def process; end -end -class Pry::Command::Help < Pry::ClassCommand - def command_groups; end - def display_command(command); end - def display_filtered_commands(search); end - def display_filtered_search_results(search); end - def display_index(groups); end - def display_search(search); end - def group_sort_key(group_name); end - def help_text_for_commands(name, commands); end - def normalize(key); end - def process; end - def search_hash(search, hash); end - def sorted_commands(commands); end - def sorted_group_names(groups); end - def visible_commands; end -end -class Pry::Command::Hist < Pry::ClassCommand - def check_for_juxtaposed_replay(replay_sequence); end - def find_history; end - def options(opt); end - def process; end - def process_clear; end - def process_display; end - def process_replay; end - def process_save; end -end -class Pry::Command::ImportSet < Pry::ClassCommand - def process(_command_set_name); end -end -class Pry::Command::JumpTo < Pry::ClassCommand - def process(break_level); end -end -class Pry::Command::ListInspectors < Pry::ClassCommand - def inspector_map; end - def process; end - def selected_inspector?(inspector); end - def selected_text; end -end -class Pry::Command::Nesting < Pry::ClassCommand - def process; end -end -class Pry::Command::Play < Pry::ClassCommand - def code_object; end - def content; end - def content_after_options; end - def content_at_expression; end - def default_file; end - def file_content; end - def options(opt); end - def perform_play; end - def process; end - def should_use_default_file?; end - def show_input; end -end -class Pry::Command::PryBacktrace < Pry::ClassCommand - def process; end -end -class Pry::Command::Version < Pry::ClassCommand - def process; end -end -class Pry::Command::RaiseUp < Pry::ClassCommand - def process; end -end -class Pry::Command::ReloadCode < Pry::ClassCommand - def check_for_reloadability(code_object, identifier); end - def current_file; end - def process; end - def reload_current_file; end - def reload_object(identifier); end -end -class Pry::Command::Reset < Pry::ClassCommand - def process; end -end -class Pry::Command::Ri < Pry::ClassCommand - def process(spec); end -end -class Pry::Command::SaveFile < Pry::ClassCommand - def display_content; end - def file_name; end - def mode; end - def options(opt); end - def process; end - def save_file; end -end -class Pry::Command::ShellCommand < Pry::ClassCommand - def cd_path_env; end - def cd_path_exists?; end - def parse_destination(dest); end - def path_from_cd_path(dest); end - def process(cmd); end - def process_cd(dest); end - def special_case_path?(dest); end -end -class Pry::Command::ShellMode < Pry::ClassCommand - def process; end -end -class Pry::Command::ShowInfo < Pry::ClassCommand - def code_object_header(code_object, line_num); end - def code_object_with_accessible_source(code_object); end - def complete(input); end - def content_and_header_for_code_object(code_object); end - def content_and_headers_for_all_module_candidates(mod); end - def file_and_line_for(code_object); end - def header(code_object); end - def header_options; end - def initialize(*arg0); end - def method_header(code_object, line_num); end - def method_sections(code_object); end - def module_header(code_object, line_num); end - def no_definition_message; end - def obj_name; end - def options(opt); end - def process; end - def show_all_modules?(code_object); end - def start_line_for(code_object); end - def use_line_numbers?; end - def valid_superclass?(code_object); end - extend Pry::Helpers::BaseHelpers -end -class Pry::Command::ShowDoc < Pry::Command::ShowInfo - def content_for(code_object); end - def docs_for(code_object); end - def header_options; end - def process; end - def render_doc_markup_for(code_object); end - def start_line_for(code_object); end - include Pry::Helpers::DocumentationHelpers -end -class Pry::Command::ShowInput < Pry::ClassCommand - def process; end -end -class Pry::Command::ShowSource < Pry::Command::ShowInfo - def content_for(code_object); end - def docs_for(code_object); end - def header_options; end - def options(opt); end - def process; end - def render_doc_markup_for(code_object); end - def start_line_for(code_object); end - include Pry::Helpers::DocumentationHelpers -end -class Pry::Command::Stat < Pry::ClassCommand - def options(opt); end - def process; end -end -class Pry::Command::SwitchTo < Pry::ClassCommand - def process(selection); end -end -class Pry::Command::ToggleColor < Pry::ClassCommand - def color_toggle; end - def process; end -end -class Pry::Command::WatchExpression < Pry::ClassCommand - def add_expression(_arguments); end - def add_hook; end - def delete(index); end - def eval_and_print_changed(output); end - def expressions; end - def list; end - def options(opt); end - def process; end -end -class Pry::Command::WatchExpression::Expression - def changed?; end - def eval!; end - def initialize(pry_instance, target, source); end - def previous_value; end - def pry_instance; end - def source; end - def target; end - def target_eval(target, source); end - def to_s; end - def value; end -end -class Pry::Command::Whereami < Pry::ClassCommand - def bad_option_combination?; end - def class_code; end - def code; end - def code?; end - def code_window; end - def default_code; end - def expand_path(filename); end - def handle_internal_binding; end - def initialize(*arg0); end - def location; end - def marker; end - def method_code; end - def nothing_to_do?; end - def options(opt); end - def process; end - def self.method_size_cutoff; end - def self.method_size_cutoff=(arg0); end - def setup; end - def small_method?; end - def target_class; end - def top_level?; end - def use_line_numbers?; end - def valid_method?; end - def window_size; end -end -class Pry::Command::Wtf < Pry::ClassCommand - def format_backtrace(backtrace); end - def format_header(title, exception); end - def options(opt); end - def process; end - def read_line(file, line); end - def trim_backtrace(backtrace); end - def unwind_exceptions; end -end diff --git a/sorbet/rbi/gems/pry@0.14.1.rbi b/sorbet/rbi/gems/pry@0.14.1.rbi new file mode 100644 index 00000000..0017bd1c --- /dev/null +++ b/sorbet/rbi/gems/pry@0.14.1.rbi @@ -0,0 +1,10084 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `pry` gem. +# Please instead update this file by running `bin/tapioca gem pry`. + +# source://yard-0.9.28/lib/yard.rb:62 +::RUBY19 = T.let(T.unsafe(nil), TrueClass) + +# source://pry-0.14.1/lib/pry/core_extensions.rb:115 +class BasicObject + # Return a binding object for the receiver. + # + # The `self` of the binding is set to the current object, and it contains no + # local variables. + # + # The default definee (http://yugui.jp/articles/846) is set such that new + # methods defined will be added to the singleton class of the BasicObject. + # + # @return [Binding] + # + # source://pry-0.14.1/lib/pry/core_extensions.rb:125 + def __binding__; end +end + +# source://pry-0.14.1/lib/pry/core_extensions.rb:24 +class Object < ::BasicObject + include ::Kernel + + # Return a binding object for the receiver. + # + # The `self` of the binding is set to the current object, and it contains no + # local variables. + # + # The default definee (http://yugui.jp/articles/846) is set such that: + # + # * If `self` is a class or module, then new methods created in the binding + # will be defined in that class or module (as in `class Foo; end`). + # * If `self` is a normal object, then new methods created in the binding will + # be defined on its singleton class (as in `class << self; end`). + # * If `self` doesn't have a real singleton class (i.e. it is a Fixnum, Float, + # Symbol, nil, true, or false), then new methods will be created on the + # object's class (as in `self.class.class_eval{ }`) + # + # Newly created constants, including classes and modules, will also be added + # to the default definee. + # + # @return [Binding] + # + # source://pry-0.14.1/lib/pry/core_extensions.rb:70 + def __binding__; end + + # Start a Pry REPL on self. + # + # If `self` is a Binding then that will be used to evaluate expressions; + # otherwise a new binding will be created. + # + # @example With a binding + # binding.pry + # @example On any object + # "dummy".pry + # @example With options + # def my_method + # binding.pry :quiet => true + # end + # my_method() + # @param object [Object] the object or binding to pry + # (__deprecated__, use `object.pry`) + # @param hash [Hash] the options hash + # @see Pry.start + # + # source://pry-0.14.1/lib/pry/core_extensions.rb:43 + def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end +end + +# {Pry::LastException} is a proxy class who wraps an Exception object for +# {Pry#last_exception}. it extends the exception object with methods that +# help pry commands be useful. +# +# the original exception object is not modified and method calls are forwarded +# to the wrapped exception object. +# +# source://pry-0.14.1/lib/pry/version.rb:3 +class Pry + extend ::Forwardable + extend ::Pry::Forwardable + + # Create a new {Pry} instance. + # + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @param options [Hash] + # @return [Pry] a new instance of Pry + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:81 + def initialize(options = T.unsafe(nil)); end + + # Add a sticky local to this Pry instance. + # A sticky local is a local that persists between all bindings in a session. + # + # @param name [Symbol] The name of the sticky local. + # @yield The block that defines the content of the local. The local + # will be refreshed at each tick of the repl loop. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:212 + def add_sticky_local(name, &block); end + + # Returns the value of attribute backtrace. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:35 + def backtrace; end + + # Sets the attribute backtrace + # + # @param value the value to set the attribute backtrace to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:35 + def backtrace=(_arg0); end + + # Returns the value of attribute binding_stack. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:32 + def binding_stack; end + + # Sets the attribute binding_stack + # + # @param value the value to set the attribute binding_stack to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:32 + def binding_stack=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands=(*args, &block); end + + # Generate completions. + # + # @param str [String] What the user has typed so far + # @return [Array] Possible completions + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:145 + def complete(str); end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:50 + def config; end + + # The currently active `Binding`. + # + # @return [Binding] The currently active `Binding` for the session. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:124 + def current_binding; end + + # The currently active `Binding`. + # support previous API + # + # @return [Binding] The currently active `Binding` for the session. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:124 + def current_context; end + + # Returns the value of attribute custom_completions. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:33 + def custom_completions; end + + # Sets the attribute custom_completions + # + # @param value the value to set the attribute custom_completions to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:33 + def custom_completions=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor=(*args, &block); end + + # Pass a line of input to Pry. + # + # This is the equivalent of `Binding#eval` but with extra Pry! + # + # In particular: + # 1. Pry commands will be executed immediately if the line matches. + # 2. Partial lines of input will be queued up until a complete expression has + # been accepted. + # 3. Output is written to `#output` in pretty colours, not returned. + # + # Once this method has raised an exception or returned false, this instance + # is no longer usable. {#exit_value} will return the session's breakout + # value if applicable. + # + # @option options + # @param line [String?] The line of input; `nil` if the user types `` + # @param options [Hash] a customizable set of options + # @raise [Exception] If the user uses the `raise-up` command, this method + # will raise that exception. + # @return [Boolean] Is Pry ready to accept more input? + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:255 + def eval(line, options = T.unsafe(nil)); end + + # Returns the value of attribute eval_string. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:34 + def eval_string; end + + # Sets the attribute eval_string + # + # @param value the value to set the attribute eval_string to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:34 + def eval_string=(_arg0); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:286 + def evaluate_ruby(code); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler=(*args, &block); end + + # Execute the specified hook. + # If executing a hook raises an exception, we log that and then continue sucessfully. + # To debug such errors, use the global variable $pry_hook_error, which is set as a + # result. + # + # @param name [Symbol] The hook name to execute + # @param args [*Object] The arguments to pass to the hook + # @return [Object, Exception] The return value of the hook or the exception raised + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:394 + def exec_hook(name, *args, &block); end + + # Returns the value of attribute exit_value. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:42 + def exit_value; end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks=(*args, &block); end + + # Injects a local variable into the provided binding. + # + # @param name [String] The name of the local to inject. + # @param value [Object] The value to set the local to. + # @param binding [Binding] The binding to set the local on. + # @return [Object] The value the local was set to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:173 + def inject_local(name, value, binding); end + + # Inject all the sticky locals into the current binding. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:201 + def inject_sticky_locals!; end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input=(*args, &block); end + + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:45 + def input_ring; end + + # Returns the value of attribute last_dir. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:39 + def last_dir; end + + # Sets the attribute last_dir + # + # @param value the value to set the attribute last_dir to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:39 + def last_dir=(_arg0); end + + # Returns the value of attribute last_exception. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:41 + def last_exception; end + + # Set the last exception for a session. + # + # @param exception [Exception] The last exception. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:418 + def last_exception=(exception); end + + # Returns the value of attribute last_file. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:38 + def last_file; end + + # Sets the attribute last_file + # + # @param value the value to set the attribute last_file to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:38 + def last_file=(_arg0); end + + # Returns the value of attribute last_result. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:37 + def last_result; end + + # Sets the attribute last_result + # + # @param value the value to set the attribute last_result to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:37 + def last_result=(_arg0); end + + # @return [Boolean] True if the last result is an exception that was raised, + # as opposed to simply an instance of Exception (like the result of + # Exception.new) + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:440 + def last_result_is_exception?; end + + # @return [Integer] The maximum amount of objects remembered by the inp and + # out arrays. Defaults to 100. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:190 + def memory_size; end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:195 + def memory_size=(size); end + + # Returns an output device + # + # @example + # pry_instance.output.puts "ohai!" + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:538 + def output; end + + # source://RUBY_ROOT/forwardable.rb:226 + def output=(*args, &block); end + + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:48 + def output_ring; end + + # Returns the currently configured pager + # + # @example + # pry_instance.pager.page text + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:530 + def pager; end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager=(*args, &block); end + + # Pops the current prompt off of the prompt stack. If the prompt you are + # popping is the last prompt, it will not be popped. Use this to restore the + # previous prompt. + # + # @example + # pry = Pry.new(prompt: Pry::Prompt[:my_prompt1]) + # pry.push_prompt(Pry::Prompt[:my_prompt2]) + # pry.pop_prompt # => prompt2 + # pry.pop_prompt # => prompt1 + # pry.pop_prompt # => prompt1 + # @return [Pry::Prompt] the prompt being popped + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:522 + def pop_prompt; end + + # source://RUBY_ROOT/forwardable.rb:226 + def print(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print=(*args, &block); end + + # If the given line is a valid command, process it in the context of the + # current `eval_string` and binding. + # + # @param val [String] The line to process. + # @return [Boolean] `true` if `val` is a command, `false` otherwise + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:325 + def process_command(val); end + + # Same as process_command, but outputs exceptions to `#output` instead of + # raising. + # + # @param val [String] The line to process. + # @return [Boolean] `true` if `val` is a command, `false` otherwise + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:360 + def process_command_safely(val); end + + # This is the prompt at the top of the prompt stack. + # + # @return [Pry::Prompt] the current prompt + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:101 + def prompt; end + + # Sets the Pry prompt. + # + # @param new_prompt [Pry::Prompt] + # @return [void] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:108 + def prompt=(new_prompt); end + + # Push a binding for the given object onto the stack. If this instance is + # currently stopped, mark it as usable again. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:131 + def push_binding(object); end + + # Initialize this instance by pushing its initial context into the binding + # stack. If no target is given, start at the top level. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:118 + def push_initial_binding(target = T.unsafe(nil)); end + + # Pushes the current prompt onto a stack that it can be restored from later. + # Use this if you wish to temporarily change the prompt. + # + # @example + # push_prompt(Pry::Prompt[:my_prompt]) + # @param new_prompt [Pry::Prompt] + # @return [Pry::Prompt] new_prompt + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:506 + def push_prompt(new_prompt); end + + # Convenience accessor for the `quiet` config key. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:592 + def quiet?; end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:582 + def raise_up(*args); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:586 + def raise_up!(*args); end + + # Raise an exception out of Pry. + # + # See Kernel#raise for documentation of parameters. + # See rb_make_exception for the inbuilt implementation. + # + # This is necessary so that the raise-up command can tell the + # difference between an exception the user has decided to raise, + # and a mistake in specifying that exception. + # + # (i.e. raise-up RunThymeError.new should not be the same as + # raise-up NameError, "unititialized constant RunThymeError") + # + # @raise [TypeError] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:554 + def raise_up_common(force, *args); end + + # Potentially deprecated. Use `Pry::REPL.new(pry, :target => target).start` + # (If nested sessions are going to exist, this method is fine, but a goal is + # to come up with an alternative to nested sessions altogether.) + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:282 + def repl(target = T.unsafe(nil)); end + + # Reset the current eval string. If the user has entered part of a multiline + # expression, this discards that input. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:231 + def reset_eval_string; end + + # Run the specified command. + # + # @example + # pry_instance.run_command("ls -m") + # @param val [String] The command (and its params) to execute. + # @return [Pry::Command::VOID_VALUE] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:375 + def run_command(val); end + + # Returns the appropriate prompt to use. + # + # @return [String] The prompt. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:453 + def select_prompt; end + + # Set the last result of an eval. + # This method should not need to be invoked directly. + # + # @param result [Object] The result. + # @param code [String] The code that was run. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:409 + def set_last_result(result, code = T.unsafe(nil)); end + + # Whether the print proc should be invoked. + # Currently only invoked if the output is not suppressed. + # + # @return [Boolean] Whether the print proc should be invoked. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:447 + def should_print?; end + + # Output the result or pass to an exception handler (if result is an exception). + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:298 + def show_result(result); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:216 + def sticky_locals; end + + # Returns the value of attribute suppress_output. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:36 + def suppress_output; end + + # Sets the attribute suppress_output + # + # @param value the value to set the attribute suppress_output to. + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:36 + def suppress_output=(_arg0); end + + # Update Pry's internal state after evalling code. + # This method should not need to be invoked directly. + # + # @param code [String] The code we just eval'd + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:428 + def update_input_history(code); end + + private + + # Force `eval_string` into the encoding of `val`. [Issue #284] + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:680 + def ensure_correct_encoding!(val); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:688 + def generate_prompt(prompt_proc, conf); end + + # source://pry-0.14.1/lib/pry/pry_instance.rb:598 + def handle_line(line, options); end + + # the array that the prompt stack is stored in + # + # source://pry-0.14.1/lib/pry/pry_instance.rb:697 + def prompt_stack; end + + class << self + # Convert the given object into an instance of `Pry::Code`, if it isn't + # already one. + # + # @param obj [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array, IO] + # + # source://pry-0.14.1/lib/pry/code.rb:12 + def Code(obj); end + + # If the given object is a `Pry::Method`, return it unaltered. If it's + # anything else, return it wrapped in a `Pry::Method` instance. + # + # source://pry-0.14.1/lib/pry/method.rb:9 + def Method(obj); end + + # If the given object is a `Pry::WrappedModule`, return it unaltered. If it's + # anything else, return it wrapped in a `Pry::WrappedModule` instance. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:7 + def WrappedModule(obj); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:288 + def auto_resize!; end + + # Return a `Binding` object for `target` or return `target` if it is + # already a `Binding`. + # In the case where `target` is top-level then return `TOPLEVEL_BINDING` + # + # @param target [Object] The object to get a `Binding` object for. + # @return [Binding] The `Binding` object. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:341 + def binding_for(target); end + + # Returns the value of attribute cli. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:22 + def cli; end + + # Sets the attribute cli + # + # @param value the value to set the attribute cli to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:22 + def cli=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def color=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def commands=(*args, &block); end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:25 + def config; end + + # Sets the attribute config + # + # @param value the value to set the attribute config to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:25 + def config=(_arg0); end + + # @example + # Pry.configure do |config| + # config.eager_load! # optional + # config.input = # .. + # config.foo = 2 + # end + # @yield [config] Yields a block with {Pry.config} as its argument. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:46 + def configure; end + + # source://pry-0.14.1/lib/pry/pry_class.rb:374 + def critical_section; end + + # @return [Pry::Config] Returns a value store for an instance of Pry running on the current thread. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:63 + def current; end + + # Returns the value of attribute current_line. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:19 + def current_line; end + + # Sets the attribute current_line + # + # @param value the value to set the attribute current_line to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:19 + def current_line=(_arg0); end + + # Returns the value of attribute custom_completions. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:18 + def custom_completions; end + + # Sets the attribute custom_completions + # + # @param value the value to set the attribute custom_completions to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:18 + def custom_completions=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def editor=(*args, &block); end + + # Returns the value of attribute eval_path. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:21 + def eval_path; end + + # Sets the attribute eval_path + # + # @param value the value to set the attribute eval_path to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:21 + def eval_path=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def exception_handler=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def extra_sticky_locals=(*args, &block); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:139 + def final_session_setup; end + + # source://RUBY_ROOT/forwardable.rb:226 + def history(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def history=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def hooks=(*args, &block); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:369 + def in_critical_section?; end + + # Basic initialization. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:332 + def init; end + + # @return [Boolean] Whether this is the first time a Pry session has + # been started since loading the Pry class. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:251 + def initial_session?; end + + # Do basic setup for initial session including: loading pryrc, plugins, + # requires, and history. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:129 + def initial_session_setup; end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input=(*args, &block); end + + # Returns the value of attribute last_internal_error. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:24 + def last_internal_error; end + + # Sets the attribute last_internal_error + # + # @param value the value to set the attribute last_internal_error to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:24 + def last_internal_error=(_arg0); end + + # Returns the value of attribute line_buffer. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:20 + def line_buffer; end + + # Sets the attribute line_buffer + # + # @param value the value to set the attribute line_buffer to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:20 + def line_buffer=(_arg0); end + + # Load the given file in the context of `Pry.toplevel_binding` + # + # @param file [String] The unexpanded file path. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:69 + def load_file_at_toplevel(file); end + + # Execute the file through the REPL loop, non-interactively. + # + # @param file_name [String] File name to load through the REPL. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:196 + def load_file_through_repl(file_name); end + + # Load Readline history if required. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:245 + def load_history; end + + # Load RC files if appropriate This method can also be used to reload the + # files if they have changed. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:77 + def load_rc_files; end + + # Load any Ruby files specified with the -r flag on the command line. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:101 + def load_requires; end + + # Trap interrupts on jruby, and make them behave like MRI so we can + # catch them. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:109 + def load_traps; end + + # source://pry-0.14.1/lib/pry/pry_class.rb:113 + def load_win32console; end + + # @return [main] returns the special instance of Object, "main". + # + # source://pry-0.14.1/lib/pry/pry_class.rb:55 + def main; end + + # source://RUBY_ROOT/forwardable.rb:226 + def memory_size(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def memory_size=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pager=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def print=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prompt(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prompt=(*args, &block); end + + # Returns the value of attribute quiet. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:23 + def quiet; end + + # Sets the attribute quiet + # + # @param value the value to set the attribute quiet to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:23 + def quiet=(_arg0); end + + # Load the local RC file (./.pryrc) + # + # source://pry-0.14.1/lib/pry/pry_class.rb:86 + def rc_files_to_load; end + + # Expand a file to its canonical name (following symlinks as appropriate) + # + # source://pry-0.14.1/lib/pry/pry_class.rb:94 + def real_path_to(file); end + + # Set all the configurable options back to their default values + # + # source://pry-0.14.1/lib/pry/pry_class.rb:320 + def reset_defaults; end + + # Run a Pry command from outside a session. The commands available are + # those referenced by `Pry.config.commands` (the default command set). + # + # @example Run under Pry class, returning only public methods. + # Pry.run_command "ls -m", :target => Pry + # @example Run at top-level with no output. + # Pry.run_command "ls" + # @example Display command output. + # Pry.run_command "ls -av", :show_output => true + # @option options + # @option options + # @param command_string [String] The Pry command (including arguments, + # if any). + # @param options [Hash] Optional named parameters. + # @return [nil] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:271 + def run_command(command_string, options = T.unsafe(nil)); end + + # Start a Pry REPL. + # This method also loads `pryrc` as necessary the first time it is invoked. + # + # @example + # Pry.start(Object.new, :input => MyInput.new) + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @option options + # @param target [Object, Binding] The receiver of the Pry session + # @param options [Hash] + # + # source://pry-0.14.1/lib/pry/pry_class.rb:156 + def start(target = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/pry_class.rb:348 + def toplevel_binding; end + + # Sets the attribute toplevel_binding + # + # @param value the value to set the attribute toplevel_binding to. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:366 + def toplevel_binding=(_arg0); end + + # An inspector that clips the output to `max_length` chars. + # In case of > `max_length` chars the `# notation is used. + # + # @option options + # @option options + # @param obj [Object] The object to view. + # @param options [Hash] + # @return [String] The string representation of `obj`. + # + # source://pry-0.14.1/lib/pry/pry_class.rb:219 + def view_clip(obj, options = T.unsafe(nil)); end + end +end + +# @return [Array] Code of the method used when implementing Pry's +# __binding__, along with line indication to be used with instance_eval (and +# friends). +# @see Object#__binding__ +# +# source://pry-0.14.1/lib/pry/core_extensions.rb:9 +Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/basic_object.rb:4 +class Pry::BasicObject < ::BasicObject + include ::Kernel +end + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::Dir = Dir + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object) + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::File = File + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::Kernel = Kernel + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::LoadError = LoadError + +# source://pry-0.14.1/lib/pry/basic_object.rb:6 +Pry::BasicObject::Pry = Pry + +# A super-class for Commands that are created with a single block. +# +# This class ensures that the block is called with the correct number of +# arguments and the right context. +# +# Create subclasses using {Pry::CommandSet#command}. +# +# source://pry-0.14.1/lib/pry/block_command.rb:13 +class Pry::BlockCommand < ::Pry::Command + # Call the block that was registered with this command. + # + # @param args [Array] The arguments passed + # @return [Object] The return value of the block + # + # source://pry-0.14.1/lib/pry/block_command.rb:14 + def call(*args); end + + # source://pry-0.14.1/lib/pry/block_command.rb:18 + def help; end +end + +# Manage the processing of command line options +# +# source://pry-0.14.1/lib/pry/cli.rb:7 +class Pry::CLI + class << self + # Add a block responsible for processing parsed options. + # + # source://pry-0.14.1/lib/pry/cli.rb:39 + def add_option_processor(&block); end + + # Add another set of CLI options (a Pry::Slop block) + # + # source://pry-0.14.1/lib/pry/cli.rb:24 + def add_options(&block); end + + # @return [Array] The input array of strings to process + # as CLI options. + # + # source://pry-0.14.1/lib/pry/cli.rb:21 + def input_args; end + + # @return [Array] The input array of strings to process + # as CLI options. + # + # source://pry-0.14.1/lib/pry/cli.rb:21 + def input_args=(_arg0); end + + # @return [Array] The Procs that process the parsed options. Plugins can + # utilize this facility in order to add and process their own Pry + # options. + # + # source://pry-0.14.1/lib/pry/cli.rb:17 + def option_processors; end + + # @return [Array] The Procs that process the parsed options. Plugins can + # utilize this facility in order to add and process their own Pry + # options. + # + # source://pry-0.14.1/lib/pry/cli.rb:17 + def option_processors=(_arg0); end + + # @return [Proc] The Proc defining the valid command line options. + # + # source://pry-0.14.1/lib/pry/cli.rb:12 + def options; end + + # @return [Proc] The Proc defining the valid command line options. + # + # source://pry-0.14.1/lib/pry/cli.rb:12 + def options=(_arg0); end + + # source://pry-0.14.1/lib/pry/cli.rb:52 + def parse_options(args = T.unsafe(nil)); end + + # Clear `options` and `option_processors` + # + # source://pry-0.14.1/lib/pry/cli.rb:47 + def reset; end + + # source://pry-0.14.1/lib/pry/cli.rb:90 + def start(opts); end + end +end + +# source://pry-0.14.1/lib/pry/cli.rb:8 +class Pry::CLI::NoOptionsError < ::StandardError; end + +# A super-class of Commands with structure. +# +# This class implements the bare-minimum functionality that a command should +# have, namely a --help switch, and then delegates actual processing to its +# subclasses. +# +# Create subclasses using {Pry::CommandSet#create_command}, and override the +# `options(opt)` method to set up an instance of Pry::Slop, and the `process` +# method to actually run the command. If necessary, you can also override +# `setup` which will be called before `options`, for example to require any +# gems your command needs to run, or to set up state. +# +# source://pry-0.14.1/lib/pry/class_command.rb:15 +class Pry::ClassCommand < ::Pry::Command + # Returns the value of attribute args. + # + # source://pry-0.14.1/lib/pry/class_command.rb:64 + def args; end + + # Sets the attribute args + # + # @param value the value to set the attribute args to. + # + # source://pry-0.14.1/lib/pry/class_command.rb:64 + def args=(_arg0); end + + # Set up `opts` and `args`, and then call `process`. + # + # This method will display help if necessary. + # + # @param args [Array] The arguments passed + # @return [Object] The return value of `process` or VOID_VALUE + # + # source://pry-0.14.1/lib/pry/class_command.rb:72 + def call(*args); end + + # Generate shell completions + # + # @param search [String] The line typed so far + # @return [Array] the words to complete + # + # source://pry-0.14.1/lib/pry/class_command.rb:105 + def complete(search); end + + # Return the help generated by Pry::Slop for this command. + # + # source://pry-0.14.1/lib/pry/class_command.rb:87 + def help; end + + # A method to setup Pry::Slop so it can parse the options your command expects. + # + # method, as it may be called by Pry at any time for introspection reasons. + # If you need to set up default values, use `setup` instead. + # + # @example + # def options(opt) + # opt.banner "Gists methods or classes" + # opt.on(:c, :class, "gist a class") do + # @action = :class + # end + # end + # @note Please don't do anything side-effecty in the main part of this + # + # source://pry-0.14.1/lib/pry/class_command.rb:171 + def options(opt); end + + # Returns the value of attribute opts. + # + # source://pry-0.14.1/lib/pry/class_command.rb:63 + def opts; end + + # Sets the attribute opts + # + # @param value the value to set the attribute opts to. + # + # source://pry-0.14.1/lib/pry/class_command.rb:63 + def opts=(_arg0); end + + # The actual body of your command should go here. + # + # The `opts` mehod can be called to get the options that Pry::Slop has passed, + # and `args` gives the remaining, unparsed arguments. + # + # The return value of this method is discarded unless the command was + # created with `:keep_retval => true`, in which case it is returned to the + # repl. + # + # @example + # def process + # if opts.present?(:class) + # gist_class + # else + # gist_method + # end + # end + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/class_command.rb:190 + def process; end + + # A method called just before `options(opt)` as part of `call`. + # + # This method can be used to set up any context your command needs to run, + # for example requiring gems, or setting default values for options. + # + # @example + # def setup + # require 'gist' + # @action = :method + # end + # + # source://pry-0.14.1/lib/pry/class_command.rb:121 + def setup; end + + # Return an instance of Pry::Slop that can parse either subcommands or the + # options that this command accepts. + # + # source://pry-0.14.1/lib/pry/class_command.rb:93 + def slop; end + + # A method to setup Pry::Slop commands so it can parse the subcommands your + # command expects. If you need to set up default values, use `setup` + # instead. + # + # @example A minimal example + # def subcommands(cmd) + # cmd.command :download do |opt| + # description 'Downloads a content from a server' + # + # opt.on :verbose, 'Use verbose output' + # + # run do |options, arguments| + # ContentDownloader.download(options, arguments) + # end + # end + # end + # @example Define the invokation block anywhere you want + # def subcommands(cmd) + # cmd.command :download do |opt| + # description 'Downloads a content from a server' + # + # opt.on :verbose, 'Use verbose output' + # end + # end + # + # def process + # # Perform calculations... + # opts.fetch_command(:download).run do |options, arguments| + # ContentDownloader.download(options, arguments) + # end + # # More calculations... + # end + # + # source://pry-0.14.1/lib/pry/class_command.rb:156 + def subcommands(cmd); end + + class << self + # source://pry-0.14.1/lib/pry/class_command.rb:29 + def doc; end + + # source://pry-0.14.1/lib/pry/class_command.rb:37 + def file; end + + # Ensure that subclasses inherit the options, description and + # match from a ClassCommand super class. + # + # source://pry-0.14.1/lib/pry/class_command.rb:19 + def inherited(klass); end + + # source://pry-0.14.1/lib/pry/class_command.rb:42 + def line; end + + # source://pry-0.14.1/lib/pry/class_command.rb:25 + def source; end + + # source://pry-0.14.1/lib/pry/class_command.rb:37 + def source_file; end + + # source://pry-0.14.1/lib/pry/class_command.rb:42 + def source_line; end + + # source://pry-0.14.1/lib/pry/class_command.rb:33 + def source_location; end + + private + + # The object used to extract the source for the command. + # + # This should be a `Pry::Method(block)` for a command made with `create_command` + # and a `Pry::WrappedModule(self)` for a command that's a standard class. + # + # @return [Pry::WrappedModule, Pry::Method] + # + # source://pry-0.14.1/lib/pry/class_command.rb:54 + def source_object; end + end +end + +# `Pry::Code` is a class that encapsulates lines of source code and their +# line numbers and formats them for terminal output. It can read from a file +# or method definition or be instantiated with a `String` or an `Array`. +# +# In general, the formatting methods in `Code` return a new `Code` object +# which will format the text as specified when `#to_s` is called. This allows +# arbitrary chaining of formatting methods without mutating the original +# object. +# +# source://pry-0.14.1/lib/pry/code.rb:32 +class Pry::Code + extend ::MethodSource::CodeHelpers + + # Instantiate a `Code` object containing code from the given `Array`, + # `String`, or `IO`. The first line will be line 1 unless specified + # otherwise. If you need non-contiguous line numbers, you can create an + # empty `Code` object and then use `#push` to insert the lines. + # + # @param lines [Array, String, IO] + # @param start_line [Integer?] + # @param code_type [Symbol?] + # @return [Code] a new instance of Code + # + # source://pry-0.14.1/lib/pry/code.rb:87 + def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end + + # Append the given line. +lineno+ is one more than the last existing + # line, unless specified otherwise. + # + # @param line [String] + # @return [void] + # + # source://pry-0.14.1/lib/pry/code.rb:102 + def <<(line); end + + # Two `Code` objects are equal if they contain the same lines with the same + # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings. + # + # @param other [Code, Object] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code.rb:325 + def ==(other); end + + # Remove all lines except for the +lines+ after and excluding +lineno+. + # + # @param lineno [Integer] + # @param lines [Integer] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:195 + def after(lineno, lines = T.unsafe(nil)); end + + # Remove all lines except for the +lines+ on either side of and including + # +lineno+. + # + # @param lineno [Integer] + # @param lines [Integer] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:182 + def around(lineno, lines = T.unsafe(nil)); end + + # Remove all lines except for the +lines+ up to and excluding +lineno+. + # + # @param lineno [Integer] + # @param lines [Integer] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:168 + def before(lineno, lines = T.unsafe(nil)); end + + # Remove all lines that aren't in the given range, expressed either as a + # `Range` object or a first and last line number (inclusive). Negative + # indices count from the end of the array of lines. + # + # @param start_line [Range, Integer] + # @param end_line [Integer?] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:135 + def between(start_line, end_line = T.unsafe(nil)); end + + # @return [Symbol] The type of code stored in this wrapper. + # + # source://pry-0.14.1/lib/pry/code.rb:77 + def code_type; end + + # @return [Symbol] The type of code stored in this wrapper. + # + # source://pry-0.14.1/lib/pry/code.rb:77 + def code_type=(_arg0); end + + # Get the comment that describes the expression on the given line number. + # + # @param line_number [Integer] (1-based) + # @return [String] the code. + # + # source://pry-0.14.1/lib/pry/code.rb:286 + def comment_describing(line_number); end + + # Get the multiline expression that starts on the given line number. + # + # @param line_number [Integer] (1-based) + # @return [String] the code. + # + # source://pry-0.14.1/lib/pry/code.rb:294 + def expression_at(line_number, consume = T.unsafe(nil)); end + + # Remove all lines that don't match the given `pattern`. + # + # @param pattern [Regexp] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:207 + def grep(pattern); end + + # @return [String] a (possibly highlighted) copy of the source code. + # + # source://pry-0.14.1/lib/pry/code.rb:263 + def highlighted; end + + # Return the number of lines stored. + # + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/code.rb:316 + def length; end + + # @return [Integer] the number of digits in the last line. + # + # source://pry-0.14.1/lib/pry/code.rb:252 + def max_lineno_width; end + + # Forward any missing methods to the output of `#to_s`. + # + # source://pry-0.14.1/lib/pry/code.rb:335 + def method_missing(method_name, *args, &block); end + + # Get the (approximate) Module.nesting at the give line number. + # + # @param line_number [Integer] line number starting from 1 + # @return [Array] a list of open modules. + # + # source://pry-0.14.1/lib/pry/code.rb:302 + def nesting_at(line_number); end + + # Writes a formatted representation (based on the configuration of the + # object) to the given output, which must respond to `#<<`. + # + # source://pry-0.14.1/lib/pry/code.rb:269 + def print_to_output(output, color = T.unsafe(nil)); end + + # Append the given line. +lineno+ is one more than the last existing + # line, unless specified otherwise. + # + # @param line [String] + # @return [void] + # + # source://pry-0.14.1/lib/pry/code.rb:102 + def push(line); end + + # Return an unformatted String of the code. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/code.rb:309 + def raw; end + + # Filter the lines using the given block. + # + # @return [Code] + # @yield [LOC] + # + # source://pry-0.14.1/lib/pry/code.rb:122 + def reject(&block); end + + # Filter the lines using the given block. + # + # @return [Code] + # @yield [LOC] + # + # source://pry-0.14.1/lib/pry/code.rb:112 + def select(&block); end + + # Take `num_lines` from `start_line`, forward or backwards. + # + # @param start_line [Integer] + # @param num_lines [Integer] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:150 + def take_lines(start_line, num_lines); end + + # @return [String] a formatted representation (based on the configuration of + # the object). + # + # source://pry-0.14.1/lib/pry/code.rb:258 + def to_s; end + + # Format output with the specified number of spaces in front of every line, + # unless `spaces` is falsy. + # + # @param spaces [Integer?] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:244 + def with_indentation(spaces = T.unsafe(nil)); end + + # Format output with line numbers next to it, unless `y_n` is falsy. + # + # @param y_n [Boolean?] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:221 + def with_line_numbers(y_n = T.unsafe(nil)); end + + # Format output with a marker next to the given +lineno+, unless +lineno+ is + # falsy. + # + # @param lineno [Integer?] + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:232 + def with_marker(lineno = T.unsafe(nil)); end + + protected + + # An abstraction of the `dup.instance_eval` pattern used throughout this + # class. + # + # source://pry-0.14.1/lib/pry/code.rb:361 + def alter(&block); end + + private + + # Check whether String responds to missing methods. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code.rb:345 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end + + class << self + # Instantiate a `Code` object containing code loaded from a file or + # Pry's line buffer. + # + # @param filename [String] The name of a file, or "(pry)". + # @param code_type [Symbol] The type of code the file contains. + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:42 + def from_file(filename, code_type = T.unsafe(nil)); end + + # Instantiate a `Code` object containing code extracted from a + # `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object. + # + # @param meth [::Method, UnboundMethod, Proc, Pry::Method] The method + # object. + # @param start_line [Integer, nil] The line number to start on, or nil to + # use the method's original line numbers. + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:55 + def from_method(meth, start_line = T.unsafe(nil)); end + + # Attempt to extract the source code for module (or class) `mod`. + # + # @param mod [Module, Class] The module (or class) of interest. + # @param candidate_rank [Integer] The module candidate (by rank) + # to use (see `Pry::WrappedModule::Candidate` for more information). + # @param start_line [Integer, nil] The line number to start on, or nil to + # use the method's original line numbers. + # @return [Code] + # + # source://pry-0.14.1/lib/pry/code.rb:69 + def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end + end +end + +# Represents a range of lines in a code listing. +# +# @api private +# +# source://pry-0.14.1/lib/pry/code/code_range.rb:8 +class Pry::Code::CodeRange + # @api private + # @param start_line [Integer] + # @param end_line [Integer?] + # @return [CodeRange] a new instance of CodeRange + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:11 + def initialize(start_line, end_line = T.unsafe(nil)); end + + # @api private + # @param lines [Array] + # @return [Range] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:19 + def indices_range(lines); end + + private + + # @api private + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:27 + def end_line; end + + # @api private + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:57 + def find_end_index(lines); end + + # @api private + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:50 + def find_start_index(lines); end + + # If `end_line` is equal to `nil`, then calculate it from the first + # parameter, `start_line`. Otherwise, leave it as it is. + # + # @api private + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:32 + def force_set_end_line; end + + # Finds indices of `start_line` and `end_line` in the given Array of + # +lines+. + # + # @api private + # @param lines [Array] + # @return [Array] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:45 + def indices(lines); end + + # For example, if the range is 4..10, then `start_line` would be equal to + # 4 and `end_line` to 10. + # + # @api private + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:66 + def set_end_line_from_range; end + + # @api private + # + # source://pry-0.14.1/lib/pry/code/code_range.rb:25 + def start_line; end +end + +# Represents a line of code (which may, in fact, contain multiple lines if +# the entirety was eval'd as a single unit following the `edit` command). +# +# A line of code is a tuple, which consists of a line and a line number. A +# `LOC` object's state (namely, the line parameter) can be changed via +# instance methods. `Pry::Code` heavily uses this class. +# +# @api private +# @example +# loc = LOC.new("def example\n :example\nend", 1) +# puts loc.line +# def example +# :example +# end +# #=> nil +# +# loc.indent(3) +# loc.line #=> " def example\n :example\nend" +# +# source://pry-0.14.1/lib/pry/code/loc.rb:23 +class Pry::Code::LOC + # @api private + # @param line [String] The line of code. + # @param lineno [Integer] The position of the +line+. + # @return [LOC] a new instance of LOC + # + # source://pry-0.14.1/lib/pry/code/loc.rb:29 + def initialize(line, lineno); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:34 + def ==(other); end + + # Prepends the line number `lineno` to the `line`. + # + # @api private + # @param max_width [Integer] + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:64 + def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end + + # Prepends a marker "=>" or an empty marker to the +line+. + # + # @api private + # @param marker_lineno [Integer] If it is equal to the `lineno`, then + # prepend a hashrocket. Otherwise, an empty marker. + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:81 + def add_marker(marker_lineno); end + + # Paints the `line` of code. + # + # @api private + # @param code_type [Symbol] + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:56 + def colorize(code_type); end + + # @api private + # + # source://pry-0.14.1/lib/pry/code/loc.rb:38 + def dup; end + + # @api private + # + # source://pry-0.14.1/lib/pry/code/loc.rb:98 + def handle_multiline_entries_from_edit_command(line, max_width); end + + # Indents the `line` with +distance+ spaces. + # + # @api private + # @param distance [Integer] + # @return [void] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:94 + def indent(distance); end + + # @api private + # @return [String] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:43 + def line; end + + # @api private + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:48 + def lineno; end + + # @api private + # @return [Array] + # + # source://pry-0.14.1/lib/pry/code/loc.rb:25 + def tuple; end +end + +# source://pry-0.14.1/lib/pry/code/code_file.rb:6 +class Pry::CodeFile + # @param filename [String] The name of a file with code to be detected + # @param code_type [Symbol] The type of code the `filename` contains + # @return [CodeFile] a new instance of CodeFile + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:41 + def initialize(filename, code_type = T.unsafe(nil)); end + + # @return [String] The code contained in the current `@filename`. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:47 + def code; end + + # @return [Symbol] The type of code stored in this wrapper. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:37 + def code_type; end + + private + + # @raise [MethodSource::SourceNotFoundError] if the `filename` is not + # readable for some reason. + # @return [String] absolute path for the given `filename`. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:64 + def abs_path; end + + # @return [Array] All the paths that contain code that Pry can use for its + # API's. Skips directories. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:80 + def code_path; end + + # @return [String] + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:110 + def from_load_path; end + + # @return [String] + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:105 + def from_pry_init_pwd; end + + # @return [String] + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:100 + def from_pwd; end + + # @param path [String] + # @return [Boolean] if the path, with or without the default ext, + # is a readable file then `true`, otherwise `false`. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:73 + def readable?(path); end + + # @param filename [String] + # @param default [Symbol] (:unknown) the file type to assume if none could be + # detected. + # @return [Symbol, nil] The SyntaxHighlighter type of a file from its + # extension, or `nil` if `:unknown`. + # + # source://pry-0.14.1/lib/pry/code/code_file.rb:89 + def type_from_filename(filename, default = T.unsafe(nil)); end +end + +# source://pry-0.14.1/lib/pry/code/code_file.rb:7 +Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String) + +# List of all supported languages. +# +# @return [Hash] +# +# source://pry-0.14.1/lib/pry/code/code_file.rb:11 +Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash) + +# source://pry-0.14.1/lib/pry/code/code_file.rb:28 +Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash) + +# Store the current working directory. This allows show-source etc. to work if +# your process has changed directory since boot. [Issue #675] +# +# source://pry-0.14.1/lib/pry/code/code_file.rb:34 +Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String) + +# This class is responsible for taking a string (identifying a +# command/class/method/etc) and returning the relevant type of object. +# For example, if the user looks up "show-source" then a +# `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then +# a `Pry::Method` object will be returned. +# +# The `CodeObject.lookup` method is responsible for 1. figuring out what kind of +# object the user wants (applying precedence rules in doing so -- i.e methods +# get precedence over commands with the same name) and 2. Returning +# the appropriate object. If the user fails to provide a string +# identifer for the object (i.e they pass in `nil` or "") then the +# object looked up will be the 'current method' or 'current class' +# associated with the Binding. +# +# TODO: This class is a clusterfuck. We need a much more robust +# concept of what a "Code Object" really is. Currently +# commands/classes/candidates/methods and so on just share a very +# ill-defined interface. +# +# source://pry-0.14.1/lib/pry/code_object.rb:22 +class Pry::CodeObject + include ::Pry::Helpers::OptionsHelpers + include ::Pry::Helpers::CommandHelpers + + # @return [CodeObject] a new instance of CodeObject + # + # source://pry-0.14.1/lib/pry/code_object.rb:82 + def initialize(str, pry_instance, options = T.unsafe(nil)); end + + # TODO: just make it so find_command_by_match_or_listing doesn't raise? + # + # source://pry-0.14.1/lib/pry/code_object.rb:94 + def command_lookup; end + + # lookup variables and constants and `self` that are not modules + # + # source://pry-0.14.1/lib/pry/code_object.rb:118 + def default_lookup; end + + # when no paramter is given (i.e CodeObject.lookup(nil)), then we + # lookup the 'current object' from the binding. + # + # source://pry-0.14.1/lib/pry/code_object.rb:102 + def empty_lookup; end + + # source://pry-0.14.1/lib/pry/code_object.rb:136 + def method_or_class_lookup; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/code_object.rb:79 + def pry_instance; end + + # Sets the attribute pry_instance + # + # @param value the value to set the attribute pry_instance to. + # + # source://pry-0.14.1/lib/pry/code_object.rb:79 + def pry_instance=(_arg0); end + + # Returns the value of attribute str. + # + # source://pry-0.14.1/lib/pry/code_object.rb:77 + def str; end + + # Sets the attribute str + # + # @param value the value to set the attribute str to. + # + # source://pry-0.14.1/lib/pry/code_object.rb:77 + def str=(_arg0); end + + # Returns the value of attribute super_level. + # + # source://pry-0.14.1/lib/pry/code_object.rb:80 + def super_level; end + + # Sets the attribute super_level + # + # @param value the value to set the attribute super_level to. + # + # source://pry-0.14.1/lib/pry/code_object.rb:80 + def super_level=(_arg0); end + + # Returns the value of attribute target. + # + # source://pry-0.14.1/lib/pry/code_object.rb:78 + def target; end + + # Sets the attribute target + # + # @param value the value to set the attribute target to. + # + # source://pry-0.14.1/lib/pry/code_object.rb:78 + def target=(_arg0); end + + private + + # Returns true if `str` looks like a method, i.e Klass#method + # We need to consider this case because method lookups should fall + # through to the `method_or_class_lookup()` method but a + # defined?() on a "Klass#method` string will see the `#` as a + # comment and only evaluate the `Klass` part. + # + # @param str [String] + # @return [Boolean] Whether the string looks like an instance method. + # + # source://pry-0.14.1/lib/pry/code_object.rb:163 + def looks_like_an_instance_method?(str); end + + # grab the nth (`super_level`) super of `obj + # + # @param obj [Object] + # @param super_level [Fixnum] How far up the super chain to ascend. + # @raise [Pry::CommandError] + # + # source://pry-0.14.1/lib/pry/code_object.rb:188 + def lookup_super(obj, super_level); end + + # We use this method to decide whether code is safe to eval. Method's are + # generally not, but everything else is. + # TODO: is just checking != "method" enough?? + # TODO: see duplication of this method in Pry::WrappedModule + # + # @param str [String] The string to lookup + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:173 + def safe_to_evaluate?(str); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:152 + def sourcable_object?(obj); end + + # source://pry-0.14.1/lib/pry/code_object.rb:181 + def target_self; end + + class << self + # source://pry-0.14.1/lib/pry/code_object.rb:69 + def lookup(str, pry_instance, options = T.unsafe(nil)); end + end +end + +# source://pry-0.14.1/lib/pry/code_object.rb:23 +module Pry::CodeObject::Helpers + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:30 + def c_method?; end + + # @note If a module defined by C was extended with a lot of methods written + # in Ruby, this method would fail. + # @return [Boolean] `true` if this module was defined by means of the C API, + # `false` if it's a Ruby module. + # + # source://pry-0.14.1/lib/pry/code_object.rb:46 + def c_module?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:38 + def command?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:34 + def module_with_yard_docs?; end + + # we need this helper as some Pry::Method objects can wrap Procs + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/code_object.rb:26 + def real_method_object?; end +end + +# PP subclass for streaming inspect output in color. +# +# source://pry-0.14.1/lib/pry/color_printer.rb:8 +class Pry::ColorPrinter < ::PP + # source://pry-0.14.1/lib/pry/color_printer.rb:25 + def pp(object); end + + # source://pry-0.14.1/lib/pry/color_printer.rb:37 + def text(str, max_width = T.unsafe(nil)); end + + private + + # source://pry-0.14.1/lib/pry/color_printer.rb:49 + def highlight_object_literal(object_literal); end + + # source://pry-0.14.1/lib/pry/color_printer.rb:55 + def inspect_object(object); end + + class << self + # source://pry-0.14.1/lib/pry/color_printer.rb:11 + def default(_output, value, pry_instance); end + + # source://pry-0.14.1/lib/pry/color_printer.rb:18 + def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end + end +end + +# The super-class of all commands, new commands should be created by calling +# {Pry::CommandSet#command} which creates a BlockCommand or +# {Pry::CommandSet#create_command} which creates a ClassCommand. Please don't +# use this class directly. +# +# source://pry-0.14.1/lib/pry/command.rb:11 +class Pry::Command + include ::Pry::Helpers::BaseHelpers + include ::Pry::Helpers::OptionsHelpers + include ::Pry::Helpers::CommandHelpers + include ::Pry::Helpers::Text + extend ::Pry::Helpers::DocumentationHelpers + extend ::Pry::CodeObject::Helpers + + # Instantiate a command, in preparation for calling it. + # + # @param context [Hash] The runtime context to use with this command. + # @return [Command] a new instance of Command + # + # source://pry-0.14.1/lib/pry/command.rb:230 + def initialize(context = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/command.rb:292 + def _pry_; end + + # Sets the attribute pry_instance + # + # @param value the value to set the attribute pry_instance to. + # + # source://pry-0.14.1/lib/pry/command.rb:217 + def _pry_=(_arg0); end + + # Returns the value of attribute arg_string. + # + # source://pry-0.14.1/lib/pry/command.rb:213 + def arg_string; end + + # Sets the attribute arg_string + # + # @param value the value to set the attribute arg_string to. + # + # source://pry-0.14.1/lib/pry/command.rb:213 + def arg_string=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:253 + def block; end + + # Returns the value of attribute captures. + # + # source://pry-0.14.1/lib/pry/command.rb:211 + def captures; end + + # Sets the attribute captures + # + # @param value the value to set the attribute captures to. + # + # source://pry-0.14.1/lib/pry/command.rb:211 + def captures=(_arg0); end + + # Display a warning if a command collides with a local/method in + # the current scope. + # + # source://pry-0.14.1/lib/pry/command.rb:329 + def check_for_command_collision(command_match, arg_string); end + + # The block we pass *into* a command so long as `:takes_block` is + # not equal to `false` + # + # @example + # my-command | do + # puts "block content" + # end + # + # source://pry-0.14.1/lib/pry/command.rb:226 + def command_block; end + + # The block we pass *into* a command so long as `:takes_block` is + # not equal to `false` + # + # @example + # my-command | do + # puts "block content" + # end + # + # source://pry-0.14.1/lib/pry/command.rb:226 + def command_block=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:261 + def command_name; end + + # source://pry-0.14.1/lib/pry/command.rb:257 + def command_options; end + + # Returns the value of attribute command_set. + # + # source://pry-0.14.1/lib/pry/command.rb:215 + def command_set; end + + # Sets the attribute command_set + # + # @param value the value to set the attribute command_set to. + # + # source://pry-0.14.1/lib/pry/command.rb:215 + def command_set=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:284 + def commands; end + + # Generate completions for this command + # + # @param _search [String] The line typed so far + # @return [Array] Completion words + # + # source://pry-0.14.1/lib/pry/command.rb:411 + def complete(_search); end + + # Returns the value of attribute context. + # + # source://pry-0.14.1/lib/pry/command.rb:214 + def context; end + + # Sets the attribute context + # + # @param value the value to set the attribute context to. + # + # source://pry-0.14.1/lib/pry/command.rb:214 + def context=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:249 + def description; end + + # Returns the value of attribute eval_string. + # + # source://pry-0.14.1/lib/pry/command.rb:212 + def eval_string; end + + # Sets the attribute eval_string + # + # @param value the value to set the attribute eval_string to. + # + # source://pry-0.14.1/lib/pry/command.rb:212 + def eval_string=(_arg0); end + + # Returns the value of attribute hooks. + # + # source://pry-0.14.1/lib/pry/command.rb:216 + def hooks; end + + # Sets the attribute hooks + # + # @param value the value to set the attribute hooks to. + # + # source://pry-0.14.1/lib/pry/command.rb:216 + def hooks=(_arg0); end + + # Revaluate the string (str) and perform interpolation. + # + # @param str [String] The string to reevaluate with interpolation. + # @return [String] The reevaluated string with interpolations + # applied (if any). + # + # source://pry-0.14.1/lib/pry/command.rb:318 + def interpolate_string(str); end + + # source://pry-0.14.1/lib/pry/command.rb:245 + def match; end + + # Make those properties accessible to instances + # + # source://pry-0.14.1/lib/pry/command.rb:241 + def name; end + + # Properties of one execution of a command (passed by {Pry#run_command} as a hash of + # context and expanded in `#initialize` + # + # source://pry-0.14.1/lib/pry/command.rb:209 + def output; end + + # Properties of one execution of a command (passed by {Pry#run_command} as a hash of + # context and expanded in `#initialize` + # + # source://pry-0.14.1/lib/pry/command.rb:209 + def output=(_arg0); end + + # Process a line that Command.matches? this command. + # + # @param line [String] The line to process + # @return [Object, Command::VOID_VALUE] + # + # source://pry-0.14.1/lib/pry/command.rb:394 + def process_line(line); end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/command.rb:217 + def pry_instance; end + + # Sets the attribute pry_instance + # + # @param value the value to set the attribute pry_instance to. + # + # source://pry-0.14.1/lib/pry/command.rb:217 + def pry_instance=(_arg0); end + + # Run a command from another command. + # + # @example + # run "show-input" + # @example + # run ".ls" + # @example + # run "amend-line", "5", 'puts "hello world"' + # @param command_string [String] The string that invokes the command + # @param args [Array] Further arguments to pass to the command + # + # source://pry-0.14.1/lib/pry/command.rb:278 + def run(command_string, *args); end + + # source://pry-0.14.1/lib/pry/command.rb:265 + def source; end + + # @example + # state.my_state = "my state" # this will not conflict with any + # # `state.my_state` used in another command. + # @return [Hash] Pry commands can store arbitrary state + # here. This state persists between subsequent command invocations. + # All state saved here is unique to the command, it does not + # need to be namespaced. + # + # source://pry-0.14.1/lib/pry/command.rb:309 + def state; end + + # Returns the value of attribute target. + # + # source://pry-0.14.1/lib/pry/command.rb:210 + def target; end + + # Sets the attribute target + # + # @param value the value to set the attribute target to. + # + # source://pry-0.14.1/lib/pry/command.rb:210 + def target=(_arg0); end + + # @return [Object] The value of `self` inside the `target` binding. + # + # source://pry-0.14.1/lib/pry/command.rb:298 + def target_self; end + + # Extract necessary information from a line that Command.matches? this + # command. + # + # Returns an array of four elements: + # + # ``` + # [String] the portion of the line that matched with the Command match + # [String] a string of all the arguments (i.e. everything but the match) + # [Array] the captures caught by the command_regex + # [Array] the arguments obtained by splitting the arg_string + # ``` + # + # @param val [String] The line of input + # @return [Array] + # + # source://pry-0.14.1/lib/pry/command.rb:356 + def tokenize(val); end + + # source://pry-0.14.1/lib/pry/command.rb:288 + def void; end + + private + + # source://pry-0.14.1/lib/pry/command.rb:485 + def after_hooks; end + + # source://pry-0.14.1/lib/pry/command.rb:481 + def before_hooks; end + + # Run the command with the given `args`. + # + # This is a public wrapper around `#call` which ensures all preconditions + # are met. + # + # @param args [Array] The arguments to pass to this command. + # @return [Object] The return value of the `#call` method, or + # {Command::VOID_VALUE}. + # + # source://pry-0.14.1/lib/pry/command.rb:425 + def call_safely(*args); end + + # Run the `#call` method and all the registered hooks. + # + # @param args [Array] The arguments to `#call` + # @return [Object] The return value from `#call` + # + # source://pry-0.14.1/lib/pry/command.rb:492 + def call_with_hooks(*args); end + + # source://pry-0.14.1/lib/pry/command.rb:476 + def find_hooks(event); end + + # Normalize method arguments according to its arity. + # + # @param method [Integer] + # @param args [Array] + # @return [Array] a (possibly shorter) array of the arguments to pass + # + # source://pry-0.14.1/lib/pry/command.rb:509 + def normalize_method_args(method, args); end + + # Pass a block argument to a command. + # + # @param arg_string [String] The arguments (as a string) passed to the command. + # We inspect these for a '| do' or a '| {' and if we find it we use it + # to start a block input sequence. Once we have a complete + # block, we save it to an accessor that can be retrieved from the command context. + # Note that if we find the '| do' or '| {' we delete this and the + # elements following it from `arg_string`. + # + # source://pry-0.14.1/lib/pry/command.rb:451 + def pass_block(arg_string); end + + # source://pry-0.14.1/lib/pry/command.rb:436 + def use_unpatched_symbol; end + + class << self + # Define or get the command's banner + # + # source://pry-0.14.1/lib/pry/command.rb:61 + def banner(arg = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/command.rb:66 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://pry-0.14.1/lib/pry/command.rb:30 + def block=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:109 + def command_name; end + + # Define or get the command's options + # + # source://pry-0.14.1/lib/pry/command.rb:51 + def command_options(arg = T.unsafe(nil)); end + + # Sets the attribute command_options + # + # @param value the value to set the attribute command_options to. + # + # source://pry-0.14.1/lib/pry/command.rb:32 + def command_options=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:165 + def command_regex; end + + # source://pry-0.14.1/lib/pry/command.rb:172 + def convert_to_regex(obj); end + + # source://pry-0.14.1/lib/pry/command.rb:89 + def default_options(match); end + + # Define or get the command's description + # + # source://pry-0.14.1/lib/pry/command.rb:45 + def description(arg = T.unsafe(nil)); end + + # Sets the attribute description + # + # @param value the value to set the attribute description to. + # + # source://pry-0.14.1/lib/pry/command.rb:31 + def description=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:75 + def doc; end + + # source://pry-0.14.1/lib/pry/command.rb:79 + def file; end + + # The group in which the command should be displayed in "help" output. + # This is usually auto-generated from directory naming, but it can be + # manually overridden if necessary. + # Group should not be changed once it is initialized. + # + # source://pry-0.14.1/lib/pry/command.rb:185 + def group(name = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/command.rb:105 + def inspect; end + + # source://pry-0.14.1/lib/pry/command.rb:84 + def line; end + + # source://pry-0.14.1/lib/pry/command.rb:35 + def match(arg = T.unsafe(nil)); end + + # Sets the attribute match + # + # @param value the value to set the attribute match to. + # + # source://pry-0.14.1/lib/pry/command.rb:33 + def match=(_arg0); end + + # How well does this command match the given line? + # + # Higher scores are better because they imply that this command matches + # the line more closely. + # + # The score is calculated by taking the number of characters at the start + # of the string that are used only to identify the command, not as part of + # the arguments. + # + # @example + # /\.(.*)/.match_score(".foo") #=> 1 + # /\.*(.*)/.match_score("...foo") #=> 3 + # 'hi'.match_score("hi there") #=> 2 + # @param val [String] A line input at the REPL + # @return [Fixnum] + # + # source://pry-0.14.1/lib/pry/command.rb:153 + def match_score(val); end + + # Should this command be called for the given line? + # + # @param val [String] A line input at the REPL + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/command.rb:133 + def matches?(val); end + + # source://pry-0.14.1/lib/pry/command.rb:101 + def name; end + + # Define or get the command's options + # backward compatibility + # + # source://pry-0.14.1/lib/pry/command.rb:51 + def options(arg = T.unsafe(nil)); end + + # Sets the attribute command_options + # + # @param value the value to set the attribute command_options to. + # + # source://pry-0.14.1/lib/pry/command.rb:32 + def options=(_arg0); end + + # source://pry-0.14.1/lib/pry/command.rb:70 + def source; end + + # source://pry-0.14.1/lib/pry/command.rb:79 + def source_file; end + + # source://pry-0.14.1/lib/pry/command.rb:84 + def source_line; end + + # source://pry-0.14.1/lib/pry/command.rb:202 + def state; end + + # Create a new command with the given properties. + # + # @param match [String, Regex] The thing that triggers this command + # @param description [String] The description to appear in `help` + # @param options [Hash] Behavioral options (see {Pry::CommandSet#command}) + # @param helpers [Module] A module of helper functions to be included. + # @return [Class] (a subclass of {Pry::Command}) + # @yield optional, used for BlockCommands + # + # source://pry-0.14.1/lib/pry/command.rb:120 + def subclass(match, description, options, helpers, &block); end + end +end + +# source://pry-0.14.1/lib/pry/commands/amend_line.rb:5 +class Pry::Command::AmendLine < ::Pry::ClassCommand + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:22 + def process; end + + private + + # @return [String] A new string with the amendments applied to it. + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:33 + def amend_input; end + + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:47 + def delete_from_array(array, range); end + + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:51 + def insert_into_array(array, range); end + + # @return [Fixnum] The number of lines currently in `eval_string` (the + # input buffer) + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:62 + def line_count; end + + # The lines (or line) that will be modified by the `amend-line`. + # + # @return [Range, Fixnum] The lines or line. + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:90 + def line_range; end + + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:56 + def replace_in_array(array, range); end + + # Returns the (one-indexed) start and end lines given by the user. + # The lines in this range will be affected by the `amend-line`. + # Returns `nil` if no lines were specified by the user. + # + # @return [Array, nil] + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:70 + def start_and_end_line_number; end + + # Takes two numbers that are 1-indexed, and returns a range (or + # number) that is 0-indexed. 1-indexed means the first element is + # indentified by 1 rather than by 0 (as is the case for Ruby arrays). + # + # @param start_line_number [Fixnum] One-indexed number. + # @param end_line_number [Fixnum] One-indexed number. + # @return [Range] The zero-indexed range. + # + # source://pry-0.14.1/lib/pry/commands/amend_line.rb:83 + def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end +end + +# source://pry-0.14.1/lib/pry/commands/bang.rb:5 +class Pry::Command::Bang < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/bang.rb:16 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/bang_pry.rb:5 +class Pry::Command::BangPry < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/bang_pry.rb:14 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/cat.rb:5 +class Pry::Command::Cat < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/cat.rb:53 + def complete(search); end + + # source://pry-0.14.1/lib/pry/commands/cat.rb:57 + def load_path_completions; end + + # source://pry-0.14.1/lib/pry/commands/cat.rb:23 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/cat.rb:38 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/cat/abstract_formatter.rb:6 +class Pry::Command::Cat::AbstractFormatter + include ::Pry::Helpers::OptionsHelpers + include ::Pry::Helpers::CommandHelpers + include ::Pry::Helpers::BaseHelpers + + private + + # source://pry-0.14.1/lib/pry/commands/cat/abstract_formatter.rb:26 + def between_lines; end + + # source://pry-0.14.1/lib/pry/commands/cat/abstract_formatter.rb:18 + def code_type; end + + # source://pry-0.14.1/lib/pry/commands/cat/abstract_formatter.rb:12 + def decorate(content); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/cat/abstract_formatter.rb:22 + def use_line_numbers?; end +end + +# source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:6 +class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter + include ::Pry::Helpers::Text + + # @return [ExceptionFormatter] a new instance of ExceptionFormatter + # + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:12 + def initialize(exception, pry_instance, opts); end + + # Returns the value of attribute ex. + # + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:7 + def ex; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:18 + def format; end + + # Returns the value of attribute opts. + # + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:8 + def opts; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:9 + def pry_instance; end + + private + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:56 + def backtrace_file; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:37 + def backtrace_level; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:60 + def backtrace_line; end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:64 + def check_for_errors; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:33 + def code_window_size; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:78 + def header; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:52 + def increment_backtrace_level; end + + # source://pry-0.14.1/lib/pry/commands/cat/exception_formatter.rb:71 + def start_and_end_line_for_code_window; end +end + +# source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:6 +class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter + # @return [FileFormatter] a new instance of FileFormatter + # + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:11 + def initialize(file_with_embedded_line, pry_instance, opts); end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:27 + def file_and_line; end + + # Returns the value of attribute file_with_embedded_line. + # + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:7 + def file_with_embedded_line; end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:22 + def format; end + + # Returns the value of attribute opts. + # + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:8 + def opts; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:9 + def pry_instance; end + + private + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:55 + def code_type; end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:43 + def code_window_size; end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:47 + def decorate(content); end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:59 + def detect_code_type_from_file(file_name); end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:35 + def file_name; end + + # source://pry-0.14.1/lib/pry/commands/cat/file_formatter.rb:39 + def line_number; end +end + +# source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:6 +class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter + # @return [InputExpressionFormatter] a new instance of InputExpressionFormatter + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:10 + def initialize(input_expressions, opts); end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:15 + def format; end + + # Returns the value of attribute input_expressions. + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:7 + def input_expressions; end + + # Sets the attribute input_expressions + # + # @param value the value to set the attribute input_expressions to. + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:7 + def input_expressions=(_arg0); end + + # Returns the value of attribute opts. + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:8 + def opts; end + + # Sets the attribute opts + # + # @param value the value to set the attribute opts to. + # + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:8 + def opts=(_arg0); end + + private + + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:42 + def normalized_expression_range; end + + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:37 + def numbered_input_items; end + + # source://pry-0.14.1/lib/pry/commands/cat/input_expression_formatter.rb:33 + def selected_input_items; end +end + +# source://pry-0.14.1/lib/pry/commands/cd.rb:5 +class Pry::Command::Cd < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/cd.rb:25 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/change_inspector.rb:5 +class Pry::Command::ChangeInspector < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/change_inspector.rb:17 + def process(inspector); end + + private + + # source://pry-0.14.1/lib/pry/commands/change_inspector.rb:28 + def inspector_map; end +end + +# source://pry-0.14.1/lib/pry/commands/change_prompt.rb:5 +class Pry::Command::ChangePrompt < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/change_prompt.rb:16 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/change_prompt.rb:20 + def process(prompt); end + + private + + # source://pry-0.14.1/lib/pry/commands/change_prompt.rb:38 + def change_prompt(prompt); end + + # source://pry-0.14.1/lib/pry/commands/change_prompt.rb:30 + def list_prompts; end +end + +# source://pry-0.14.1/lib/pry/commands/clear_screen.rb:5 +class Pry::Command::ClearScreen < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/clear_screen.rb:10 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/code_collector.rb:5 +class Pry::Command::CodeCollector + include ::Pry::Helpers::OptionsHelpers + include ::Pry::Helpers::CommandHelpers + + # @return [CodeCollector] a new instance of CodeCollector + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:23 + def initialize(args, opts, pry_instance); end + + # Returns the value of attribute args. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:8 + def args; end + + # The code object + # + # @return [Pry::WrappedModule, Pry::Method, Pry::Command] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:86 + def code_object; end + + # The content (i.e code/docs) for the selected object. + # If the user provided a bare code object, it returns the source. + # If the user provided the `-i` or `-o` switches, it returns the + # selected input/output lines joined as a string. If the user used + # `-d CODE_OBJECT` it returns the docs for that code object. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:60 + def content; end + + # The name of the explicitly given file (if any). + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:13 + def file; end + + # The name of the explicitly given file (if any). + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:13 + def file=(_arg0); end + + # The line range passed to `--lines`, converted to a 0-indexed range. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:123 + def line_range; end + + # Name of the object argument + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:128 + def obj_name; end + + # Returns the value of attribute opts. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:9 + def opts; end + + # The selected `pry_instance.input_ring` as a string, as specified by + # the `-i` switch. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:116 + def pry_input_content; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:10 + def pry_instance; end + + # The selected `pry_instance.output_ring` as a string, as specified by + # the `-o` switch. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:104 + def pry_output_content; end + + # Given a string and a range, return the `range` lines of that + # string. + # + # @param content [String] + # @param range [Range, Fixnum] + # @return [String] The string restricted to the given range + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:96 + def restrict_to_lines(content, range); end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:134 + def bad_option_combination?; end + + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:153 + def code_object_doc; end + + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:157 + def code_object_source_or_file; end + + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:175 + def convert_to_range(range); end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:171 + def could_not_locate(name); end + + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:161 + def file_content; end + + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:139 + def pry_array_content_as_string(array, ranges); end + + class << self + # Add the `--lines`, `-o`, `-i`, `-s`, `-d` options. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:30 + def inject_options(opt); end + + # Returns the value of attribute input_expression_ranges. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:16 + def input_expression_ranges; end + + # Sets the attribute input_expression_ranges + # + # @param value the value to set the attribute input_expression_ranges to. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:16 + def input_expression_ranges=(_arg0); end + + # Returns the value of attribute output_result_ranges. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:17 + def output_result_ranges; end + + # Sets the attribute output_result_ranges + # + # @param value the value to set the attribute output_result_ranges to. + # + # source://pry-0.14.1/lib/pry/commands/code_collector.rb:17 + def output_result_ranges=(_arg0); end + end +end + +# source://pry-0.14.1/lib/pry/commands/disable_pry.rb:5 +class Pry::Command::DisablePry < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/disable_pry.rb:23 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/edit.rb:5 +class Pry::Command::Edit < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/edit.rb:89 + def apply_runtime_patch; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:172 + def bad_option_combination?; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:152 + def code_object; end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:105 + def ensure_file_name_is_valid(file_name); end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:119 + def file_and_line; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:115 + def file_and_line_for_current_exception; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:78 + def file_based_exception?; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:135 + def file_edit; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:148 + def filename_argument; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:203 + def initial_temp_file_content; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:180 + def input_expression; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:195 + def never_reload?; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:25 + def options(opt); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:168 + def patch_exception?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:163 + def previously_patched?(code_object); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:215 + def probably_a_file?(str); end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:46 + def process; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:158 + def pry_method?(code_object); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:199 + def reload?(file_name = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:191 + def reloadable?; end + + # source://pry-0.14.1/lib/pry/commands/edit.rb:69 + def repl_edit; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:64 + def repl_edit?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/edit.rb:82 + def runtime_patch?; end +end + +# source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:6 +class Pry::Command::Edit::ExceptionPatcher + # @return [ExceptionPatcher] a new instance of ExceptionPatcher + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:11 + def initialize(pry_instance, state, exception_file_and_line); end + + # Returns the value of attribute file_and_line. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:9 + def file_and_line; end + + # Sets the attribute file_and_line + # + # @param value the value to set the attribute file_and_line to. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:9 + def file_and_line=(_arg0); end + + # perform the patch + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:18 + def perform_patch; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:7 + def pry_instance; end + + # Sets the attribute pry_instance + # + # @param value the value to set the attribute pry_instance to. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:7 + def pry_instance=(_arg0); end + + # Returns the value of attribute state. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:8 + def state; end + + # Sets the attribute state + # + # @param value the value to set the attribute state to. + # + # source://pry-0.14.1/lib/pry/commands/edit/exception_patcher.rb:8 + def state=(_arg0); end +end + +# source://pry-0.14.1/lib/pry/commands/edit/file_and_line_locator.rb:6 +module Pry::Command::Edit::FileAndLineLocator + class << self + # source://pry-0.14.1/lib/pry/commands/edit/file_and_line_locator.rb:8 + def from_binding(target); end + + # source://pry-0.14.1/lib/pry/commands/edit/file_and_line_locator.rb:16 + def from_code_object(code_object, filename_argument); end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/edit/file_and_line_locator.rb:24 + def from_exception(exception, backtrace_level); end + + # when file and line are passed as a single arg, e.g my_file.rb:30 + # + # source://pry-0.14.1/lib/pry/commands/edit/file_and_line_locator.rb:38 + def from_filename_argument(filename_argument); end + end +end + +# source://pry-0.14.1/lib/pry/commands/exit.rb:5 +class Pry::Command::Exit < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/exit.rb:25 + def process; end + + # source://pry-0.14.1/lib/pry/commands/exit.rb:34 + def process_pop_and_return; end +end + +# source://pry-0.14.1/lib/pry/commands/exit_all.rb:5 +class Pry::Command::ExitAll < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/exit_all.rb:18 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/exit_program.rb:5 +class Pry::Command::ExitProgram < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/exit_program.rb:18 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/find_method.rb:5 +class Pry::Command::FindMethod < ::Pry::ClassCommand + extend ::Pry::Helpers::BaseHelpers + + # source://pry-0.14.1/lib/pry/commands/find_method.rb:31 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/find_method.rb:36 + def process; end + + private + + # Return the matched lines of method source if `-c` is given or "" + # if `-c` was not given + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:100 + def additional_info(header, method); end + + # Search for all methods who's implementation matches the given regex + # within a namespace. + # + # @param namespace [Module] The namespace to search + # @return [Array] + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:186 + def content_search(namespace); end + + # source://pry-0.14.1/lib/pry/commands/find_method.rb:108 + def matched_method_lines(header, method); end + + # Search for all methods with a name that matches the given regex + # within a namespace. + # + # @param namespace [Module] The namespace to search + # @return [Array] + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:174 + def name_search(namespace); end + + # @return [Regexp] The pattern to search for. + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:48 + def pattern; end + + # pretty-print a list of matching methods. + # + # @param matches [Array] + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:80 + def print_matches(matches); end + + # Print matched methods for a class + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:90 + def print_matches_for_class(klass, grouped); end + + # Run the given block against every constant in the provided namespace. + # + # @param klass [Module] The namespace in which to start the search. + # @param done [Hash] The namespaces we've already visited (private) + # @yieldparam klass Each class/module in the namespace. + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:120 + def recurse_namespace(klass, done = T.unsafe(nil), &block); end + + # Gather all the methods in a namespace that pass the given block. + # + # @param namespace [Module] The namespace in which to search. + # @return [Array] + # @yieldparam method [Method] The method to test + # @yieldreturn [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:150 + def search_all_methods(namespace); end + + # The class to search for methods. + # We only search classes, so if the search object is an + # instance, return its class. If no search object is given + # search `target_self`. + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:67 + def search_class; end + + # Output the result of the search. + # + # @param matches [Array] + # + # source://pry-0.14.1/lib/pry/commands/find_method.rb:55 + def show_search_results(matches); end +end + +# source://pry-0.14.1/lib/pry/commands/fix_indent.rb:5 +class Pry::Command::FixIndent < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/fix_indent.rb:15 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/help.rb:5 +class Pry::Command::Help < ::Pry::ClassCommand + # Get a hash of available commands grouped by the "group" name. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:29 + def command_groups; end + + # Display help for an individual command. + # + # @param command [Pry::Command] + # + # source://pry-0.14.1/lib/pry/commands/help.rb:125 + def display_command(command); end + + # Display help for a searched item, filtered by group + # + # @param search [String] The string to search for. + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/help.rb:111 + def display_filtered_commands(search); end + + # Display help for a searched item, filtered first by group + # and if that fails, filtered by command name. + # + # @param search [String] The string to search for. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:98 + def display_filtered_search_results(search); end + + # Display the index view, with headings and short descriptions per command. + # + # @param groups [Hash>] + # + # source://pry-0.14.1/lib/pry/commands/help.rb:44 + def display_index(groups); end + + # Display help for an individual command or group. + # + # @param search [String] The string to search for. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:86 + def display_search(search); end + + # source://pry-0.14.1/lib/pry/commands/help.rb:159 + def group_sort_key(group_name); end + + # Given a group name and an array of commands, + # return the help string for those commands. + # + # @param name [String] The group name. + # @param commands [Array] + # @return [String] The generated help string. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:62 + def help_text_for_commands(name, commands); end + + # Clean search terms to make it easier to search group names + # + # @param key [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/commands/help.rb:155 + def normalize(key); end + + # source://pry-0.14.1/lib/pry/commands/help.rb:33 + def process; end + + # Find a subset of a hash that matches the user's search term. + # + # If there's an exact match a Hash of one element will be returned, + # otherwise a sub-Hash with every key that matches the search will + # be returned. + # + # @param search [String] the search term + # @param hash [Hash] the hash to search + # + # source://pry-0.14.1/lib/pry/commands/help.rb:137 + def search_hash(search, hash); end + + # Sort an array of commands by their `listing` name. + # + # @param commands [Array] The commands to sort + # @return [Array] commands sorted by listing name. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:79 + def sorted_commands(commands); end + + # @param groups [Hash] + # @return [Array] An array of sorted group names. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:71 + def sorted_group_names(groups); end + + # We only want to show commands that have descriptions, so that the + # easter eggs don't show up. + # + # source://pry-0.14.1/lib/pry/commands/help.rb:20 + def visible_commands; end +end + +# source://pry-0.14.1/lib/pry/commands/hist.rb:5 +class Pry::Command::Hist < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/hist.rb:25 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/hist.rb:43 + def process; end + + private + + # Checks +replay_sequence+ for the presence of neighboring replay calls. + # + # @example + # [1] pry(main)> hist --show 46894 + # 46894: hist --replay 46675..46677 + # [2] pry(main)> hist --show 46675..46677 + # 46675: 1+1 + # 46676: a = 100 + # 46677: hist --tail + # [3] pry(main)> hist --replay 46894 + # Error: Replay index 46894 points out to another replay call: + # `hist -r 46675..46677` + # [4] pry(main)> + # @param replay_sequence [String] The sequence of commands to be replayed + # (per saltum) + # @raise [Pry::CommandError] If +replay_sequence+ contains another + # "hist --replay" call + # @return [Boolean] `false` if +replay_sequence+ does not contain another + # "hist --replay" call + # + # source://pry-0.14.1/lib/pry/commands/hist.rb:143 + def check_for_juxtaposed_replay(replay_sequence); end + + # Finds history depending on the given switch. + # + # @return [Pry::Code] if it finds `--all` (or `-a`) switch, returns all + # entries in history. Without the switch returns only the entries from the + # current Pry session. + # + # source://pry-0.14.1/lib/pry/commands/hist.rb:168 + def find_history; end + + # source://pry-0.14.1/lib/pry/commands/hist.rb:105 + def process_clear; end + + # source://pry-0.14.1/lib/pry/commands/hist.rb:78 + def process_display; end + + # source://pry-0.14.1/lib/pry/commands/hist.rb:110 + def process_replay; end + + # source://pry-0.14.1/lib/pry/commands/hist.rb:86 + def process_save; end +end + +# source://pry-0.14.1/lib/pry/commands/import_set.rb:5 +class Pry::Command::ImportSet < ::Pry::ClassCommand + # TODO: resolve unused parameter. + # + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/import_set.rb:17 + def process(_command_set_name); end +end + +# source://pry-0.14.1/lib/pry/commands/jump_to.rb:5 +class Pry::Command::JumpTo < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/jump_to.rb:14 + def process(break_level); end +end + +# source://pry-0.14.1/lib/pry/commands/list_inspectors.rb:5 +class Pry::Command::ListInspectors < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/list_inspectors.rb:16 + def process; end + + private + + # source://pry-0.14.1/lib/pry/commands/list_inspectors.rb:28 + def inspector_map; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/list_inspectors.rb:36 + def selected_inspector?(inspector); end + + # source://pry-0.14.1/lib/pry/commands/list_inspectors.rb:32 + def selected_text; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/jruby_hacks.rb:5 +class Pry::Command::Ls < ::Pry::ClassCommand + # Exclude -q, -v and --grep because they, + # don't specify what the user wants to see. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls.rb:85 + def no_user_opts?; end + + # source://pry-0.14.1/lib/pry/commands/ls.rb:52 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/ls.rb:90 + def process; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls.rb:106 + def error_list; end + + # source://pry-0.14.1/lib/pry/commands/ls.rb:126 + def raise_errors_if_arguments_are_weird; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/constants.rb:6 +class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter + include ::Pry::Command::Ls::Interrogatable + + # @return [Constants] a new instance of Constants + # + # source://pry-0.14.1/lib/pry/commands/ls/constants.rb:14 + def initialize(interrogatee, no_user_opts, opts, pry_instance); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/constants.rb:23 + def correct_opts?; end + + # source://pry-0.14.1/lib/pry/commands/ls/constants.rb:27 + def output_self; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/constants.rb:39 + def format(mod, constants); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/constants.rb:35 + def show_deprecated_constants?; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/constants.rb:7 +Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/commands/ls.rb:6 +Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:6 +class Pry::Command::Ls::Formatter + # @return [Formatter] a new instance of Formatter + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:10 + def initialize(pry_instance); end + + # Sets the attribute grep + # + # @param value the value to set the attribute grep to. + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:7 + def grep=(_arg0); end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:8 + def pry_instance; end + + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:16 + def write_out; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:24 + def color(type, str); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:41 + def correct_opts?; end + + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:37 + def format_value(value); end + + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:49 + def grep; end + + # Add a new section to the output. + # Outputs nothing if the section would be empty. + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:30 + def output_section(heading, body); end + + # @raise [NotImplementedError] + # + # source://pry-0.14.1/lib/pry/commands/ls/formatter.rb:45 + def output_self; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/globals.rb:7 +class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter + # @return [Globals] a new instance of Globals + # + # source://pry-0.14.1/lib/pry/commands/ls/globals.rb:24 + def initialize(opts, pry_instance); end + + # source://pry-0.14.1/lib/pry/commands/ls/globals.rb:29 + def output_self; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/globals.rb:36 + def format(globals); end +end + +# Taken from "puts global_variables.inspect". +# +# source://pry-0.14.1/lib/pry/commands/ls/globals.rb:8 +Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array) + +# `$SAFE` and `$?` are thread-local, the exception stuff only works in a +# rescue clause, everything else is basically a local variable with a `$` +# in its name. +# +# source://pry-0.14.1/lib/pry/commands/ls/globals.rb:19 +Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/commands/ls/grep.rb:6 +class Pry::Command::Ls::Grep + # @return [Grep] a new instance of Grep + # + # source://pry-0.14.1/lib/pry/commands/ls/grep.rb:7 + def initialize(grep_regexp); end + + # source://pry-0.14.1/lib/pry/commands/ls/grep.rb:11 + def regexp; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/instance_vars.rb:6 +class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter + include ::Pry::Command::Ls::Interrogatable + + # @return [InstanceVars] a new instance of InstanceVars + # + # source://pry-0.14.1/lib/pry/commands/ls/instance_vars.rb:9 + def initialize(interrogatee, no_user_opts, opts, pry_instance); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/instance_vars.rb:16 + def correct_opts?; end + + # source://pry-0.14.1/lib/pry/commands/ls/instance_vars.rb:20 + def output_self; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/instance_vars.rb:34 + def format(type, vars); end +end + +# source://pry-0.14.1/lib/pry/commands/ls/interrogatable.rb:6 +module Pry::Command::Ls::Interrogatable + private + + # source://pry-0.14.1/lib/pry/commands/ls/interrogatable.rb:13 + def interrogatee_mod; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/interrogatable.rb:9 + def interrogating_a_module?; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/jruby_hacks.rb:6 +module Pry::Command::Ls::JRubyHacks + private + + # When removing jruby aliases, we want to keep the alias that is + # "least rubbish" according to this metric. + # + # source://pry-0.14.1/lib/pry/commands/ls/jruby_hacks.rb:40 + def rubbishness(name); end + + # JRuby creates lots of aliases for methods imported from java in an attempt + # to make life easier for ruby programmers. (e.g. getFooBar becomes + # get_foo_bar and foo_bar, and maybe foo_bar? if it returns a Boolean). The + # full transformations are in the assignAliases method of: + # https://github.com/jruby/jruby/blob/master/src/org/jruby/javasupport/JavaClass.java + # + # This has the unfortunate side-effect of making the output of ls even more + # incredibly verbose than it normally would be for these objects; and so we + # filter out all but the nicest of these aliases here. + # + # TODO: This is a little bit vague, better heuristics could be used. + # JRuby also has a lot of scala-specific logic, which we don't copy. + # + # source://pry-0.14.1/lib/pry/commands/ls/jruby_hacks.rb:21 + def trim_jruby_aliases(methods); end +end + +# source://pry-0.14.1/lib/pry/commands/ls/local_names.rb:6 +class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter + # @return [LocalNames] a new instance of LocalNames + # + # source://pry-0.14.1/lib/pry/commands/ls/local_names.rb:7 + def initialize(no_user_opts, args, pry_instance); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/local_names.rb:14 + def correct_opts?; end + + # source://pry-0.14.1/lib/pry/commands/ls/local_names.rb:18 + def output_self; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/local_names.rb:25 + def format(locals); end +end + +# source://pry-0.14.1/lib/pry/commands/ls/local_vars.rb:6 +class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter + # @return [LocalVars] a new instance of LocalVars + # + # source://pry-0.14.1/lib/pry/commands/ls/local_vars.rb:7 + def initialize(opts, pry_instance); end + + # source://pry-0.14.1/lib/pry/commands/ls/local_vars.rb:13 + def output_self; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/local_vars.rb:34 + def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/commands/ls/local_vars.rb:25 + def format(name_value_pairs); end +end + +# source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:6 +class Pry::Command::Ls::LsEntity + # @return [LsEntity] a new instance of LsEntity + # + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:9 + def initialize(opts); end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:18 + def entities_table; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:7 + def pry_instance; end + + private + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:32 + def constants; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:56 + def entities; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:28 + def globals; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:24 + def grep(entity); end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:44 + def instance_vars; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:48 + def local_names; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:52 + def local_vars; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:36 + def methods; end + + # source://pry-0.14.1/lib/pry/commands/ls/ls_entity.rb:40 + def self_methods; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/methods.rb:6 +class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter + include ::Pry::Command::Ls::Interrogatable + include ::Pry::Command::Ls::JRubyHacks + include ::Pry::Command::Ls::MethodsHelper + + # @return [Methods] a new instance of Methods + # + # source://pry-0.14.1/lib/pry/commands/ls/methods.rb:10 + def initialize(interrogatee, no_user_opts, opts, pry_instance); end + + # source://pry-0.14.1/lib/pry/commands/ls/methods.rb:22 + def output_self; end + + private + + # Get a lambda that can be used with `take_while` to prevent over-eager + # traversal of the Object's ancestry graph. + # + # source://pry-0.14.1/lib/pry/commands/ls/methods.rb:41 + def below_ceiling; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/methods.rb:35 + def correct_opts?; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/methods_helper.rb:6 +module Pry::Command::Ls::MethodsHelper + include ::Pry::Command::Ls::JRubyHacks + + private + + # Get all the methods that we'll want to output. + # + # source://pry-0.14.1/lib/pry/commands/ls/methods_helper.rb:12 + def all_methods(instance_methods = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/commands/ls/methods_helper.rb:34 + def format(methods); end + + # source://pry-0.14.1/lib/pry/commands/ls/methods_helper.rb:26 + def resolution_order; end +end + +# source://pry-0.14.1/lib/pry/commands/ls/self_methods.rb:6 +class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter + include ::Pry::Command::Ls::Interrogatable + include ::Pry::Command::Ls::JRubyHacks + include ::Pry::Command::Ls::MethodsHelper + + # @return [SelfMethods] a new instance of SelfMethods + # + # source://pry-0.14.1/lib/pry/commands/ls/self_methods.rb:10 + def initialize(interrogatee, no_user_opts, opts, pry_instance); end + + # source://pry-0.14.1/lib/pry/commands/ls/self_methods.rb:18 + def output_self; end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/ls/self_methods.rb:28 + def correct_opts?; end +end + +# source://pry-0.14.1/lib/pry/commands/nesting.rb:5 +class Pry::Command::Nesting < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/nesting.rb:14 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/play.rb:5 +class Pry::Command::Play < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/play.rb:74 + def code_object; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:82 + def content; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:60 + def content_after_options; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:70 + def content_at_expression; end + + # The file to play from when no code object is specified. + # e.g `play --lines 4..10` + # + # source://pry-0.14.1/lib/pry/commands/play.rb:92 + def default_file; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:102 + def file_content; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:29 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/play.rb:48 + def perform_play; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:41 + def process; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/play.rb:78 + def should_use_default_file?; end + + # source://pry-0.14.1/lib/pry/commands/play.rb:53 + def show_input; end +end + +# source://pry-0.14.1/lib/pry/commands/pry_backtrace.rb:5 +class Pry::Command::PryBacktrace < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/pry_backtrace.rb:22 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/raise_up.rb:6 +class Pry::Command::RaiseUp < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/raise_up.rb:27 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/reload_code.rb:5 +class Pry::Command::ReloadCode < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/reload_code.rb:20 + def process; end + + private + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/reload_code.rb:58 + def check_for_reloadability(code_object, identifier); end + + # source://pry-0.14.1/lib/pry/commands/reload_code.rb:32 + def current_file; end + + # source://pry-0.14.1/lib/pry/commands/reload_code.rb:42 + def reload_current_file; end + + # source://pry-0.14.1/lib/pry/commands/reload_code.rb:51 + def reload_object(identifier); end +end + +# source://pry-0.14.1/lib/pry/commands/reset.rb:5 +class Pry::Command::Reset < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/reset.rb:14 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/ri.rb:7 +class Pry::Command::Ri < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/ri.rb:21 + def process(spec); end +end + +# source://pry-0.14.1/lib/pry/commands/save_file.rb:5 +class Pry::Command::SaveFile < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/save_file.rb:50 + def display_content; end + + # source://pry-0.14.1/lib/pry/commands/save_file.rb:39 + def file_name; end + + # source://pry-0.14.1/lib/pry/commands/save_file.rb:56 + def mode; end + + # source://pry-0.14.1/lib/pry/commands/save_file.rb:21 + def options(opt); end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/save_file.rb:28 + def process; end + + # source://pry-0.14.1/lib/pry/commands/save_file.rb:43 + def save_file; end +end + +# source://pry-0.14.1/lib/pry/commands/shell_command.rb:5 +class Pry::Command::ShellCommand < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:21 + def process(cmd); end + + private + + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:50 + def cd_path_env; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:54 + def cd_path_exists?; end + + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:36 + def parse_destination(dest); end + + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:58 + def path_from_cd_path(dest); end + + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:43 + def process_cd(dest); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/shell_command.rb:68 + def special_case_path?(dest); end +end + +# source://pry-0.14.1/lib/pry/commands/shell_mode.rb:5 +class Pry::Command::ShellMode < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/shell_mode.rb:14 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/show_doc.rb:5 +class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo + include ::Pry::Helpers::DocumentationHelpers + + # The docs for code_object prepared for display. + # + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:35 + def content_for(code_object); end + + # Return docs for the code_object, adjusting for whether the code_object + # has yard docs available, in which case it returns those. + # (note we only have to check yard docs for modules since they can + # have multiple docs, but methods can only be doc'd once so we + # dont need to check them) + # + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:64 + def docs_for(code_object); end + + # Which sections to include in the 'header', can toggle: :owner, + # :signature and visibility. + # + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:76 + def header_options; end + + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:24 + def process; end + + # process the markup (if necessary) and apply colors + # + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:44 + def render_doc_markup_for(code_object); end + + # figure out start line of docs by back-calculating based on + # number of lines in the comment and the start line of the code_object + # + # @return [Fixnum] start line of docs + # + # source://pry-0.14.1/lib/pry/commands/show_doc.rb:83 + def start_line_for(code_object); end +end + +# source://pry-0.14.1/lib/pry/commands/show_info.rb:5 +class Pry::Command::ShowInfo < ::Pry::ClassCommand + extend ::Pry::Helpers::BaseHelpers + + # @return [ShowInfo] a new instance of ShowInfo + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:10 + def initialize(*_arg0); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:127 + def code_object_header(code_object, line_num); end + + # This method checks whether the `code_object` is a WrappedModule, if it + # is, then it returns the first candidate (monkeypatch) with accessible + # source (or docs). If `code_object` is not a WrappedModule (i.e a method + # or a command) then the `code_object` itself is just returned. + # + # @raise [CommandError] + # @return [Pry::WrappedModule, Pry::Method, Pry::Command] + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:61 + def code_object_with_accessible_source(code_object); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:213 + def complete(input); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:77 + def content_and_header_for_code_object(code_object); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:81 + def content_and_headers_for_all_module_candidates(mod); end + + # takes into account possible yard docs, and returns yard_file / yard_line + # Also adjusts for start line of comments (using start_line_for), which it + # has to infer by subtracting number of lines of comment from start line + # of code_object + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:205 + def file_and_line_for(code_object); end + + # Generate a header (meta-data information) for all the code + # object types: methods, modules, commands, procs... + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:106 + def header(code_object); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:173 + def header_options; end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:142 + def method_header(code_object, line_num); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:165 + def method_sections(code_object); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:151 + def module_header(code_object, line_num); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:100 + def no_definition_message; end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:185 + def obj_name; end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:16 + def options(opt); end + + # @raise [CommandError] + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:26 + def process; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:181 + def show_all_modules?(code_object); end + + # source://pry-0.14.1/lib/pry/commands/show_info.rb:193 + def start_line_for(code_object); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:189 + def use_line_numbers?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/show_info.rb:73 + def valid_superclass?(code_object); end +end + +# source://pry-0.14.1/lib/pry/commands/show_input.rb:5 +class Pry::Command::ShowInput < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/show_input.rb:15 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/show_source.rb:5 +class Pry::Command::ShowSource < ::Pry::Command::ShowInfo + include ::Pry::Helpers::DocumentationHelpers + + # The source for code_object prepared for display. + # + # source://pry-0.14.1/lib/pry/commands/show_source.rb:48 + def content_for(code_object); end + + # Return docs for the code_object, adjusting for whether the code_object + # has yard docs available, in which case it returns those. + # (note we only have to check yard docs for modules since they can + # have multiple docs, but methods can only be doc'd once so we + # dont need to check them) + # + # source://pry-0.14.1/lib/pry/commands/show_source.rb:86 + def docs_for(code_object); end + + # Which sections to include in the 'header', can toggle: :owner, + # :signature and visibility. + # + # source://pry-0.14.1/lib/pry/commands/show_source.rb:98 + def header_options; end + + # source://pry-0.14.1/lib/pry/commands/show_source.rb:31 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/show_source.rb:38 + def process; end + + # process the markup (if necessary) and apply colors + # + # source://pry-0.14.1/lib/pry/commands/show_source.rb:66 + def render_doc_markup_for(code_object); end + + # figure out start line of docs by back-calculating based on + # number of lines in the comment and the start line of the code_object + # + # @return [Fixnum] start line of docs + # + # source://pry-0.14.1/lib/pry/commands/show_source.rb:105 + def start_line_for(code_object); end +end + +# source://pry-0.14.1/lib/pry/commands/stat.rb:5 +class Pry::Command::Stat < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/stat.rb:19 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/stat.rb:23 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/switch_to.rb:5 +class Pry::Command::SwitchTo < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/switch_to.rb:14 + def process(selection); end +end + +# source://pry-0.14.1/lib/pry/commands/toggle_color.rb:5 +class Pry::Command::ToggleColor < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/toggle_color.rb:21 + def color_toggle; end + + # source://pry-0.14.1/lib/pry/commands/toggle_color.rb:16 + def process; end +end + +# represents a void return value for a command +# +# source://pry-0.14.1/lib/pry/command.rb:20 +Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object) + +# source://pry-0.14.1/lib/pry/commands/pry_version.rb:5 +class Pry::Command::Version < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/pry_version.rb:14 + def process; end +end + +# source://pry-0.14.1/lib/pry/commands/watch_expression.rb:5 +class Pry::Command::WatchExpression < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:31 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:42 + def process; end + + private + + # TODO: fix arguments. + # https://github.com/pry/pry/commit/b031df2f2f5850ee6e9018f33d35f3485a9b0423 + # + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:93 + def add_expression(_arguments); end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:98 + def add_hook; end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:59 + def delete(index); end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:84 + def eval_and_print_changed(output); end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:55 + def expressions; end + + # source://pry-0.14.1/lib/pry/commands/watch_expression.rb:69 + def list; end +end + +# source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:6 +class Pry::Command::WatchExpression::Expression + # @return [Expression] a new instance of Expression + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:9 + def initialize(pry_instance, target, source); end + + # Has the value of the expression changed? + # + # We use the pretty-printed string represenation to detect differences + # as this avoids problems with dup (causes too many differences) and == + # (causes too few) + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:29 + def changed?; end + + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:15 + def eval!; end + + # Returns the value of attribute previous_value. + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:7 + def previous_value; end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:7 + def pry_instance; end + + # Returns the value of attribute source. + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:7 + def source; end + + # Returns the value of attribute target. + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:7 + def target; end + + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:20 + def to_s; end + + # Returns the value of attribute value. + # + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:7 + def value; end + + private + + # source://pry-0.14.1/lib/pry/commands/watch_expression/expression.rb:35 + def target_eval(target, source); end +end + +# source://pry-0.14.1/lib/pry/commands/whereami.rb:7 +class Pry::Command::Whereami < ::Pry::ClassCommand + # @return [Whereami] a new instance of Whereami + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:8 + def initialize(*_arg0); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:83 + def bad_option_combination?; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:63 + def code; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:77 + def code?; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:88 + def location; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:55 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:92 + def process; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:44 + def setup; end + + private + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:171 + def class_code; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:152 + def code_window; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:144 + def default_code; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:185 + def expand_path(filename); end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:132 + def handle_internal_binding; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:124 + def marker; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:156 + def method_code; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:116 + def nothing_to_do?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:140 + def small_method?; end + + # This either returns the `target_self` + # or it returns the class of `target_self` if `target_self` is not a class. + # + # @return [Pry::WrappedModule] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:165 + def target_class; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:128 + def top_level?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:120 + def use_line_numbers?; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:180 + def valid_method?; end + + # source://pry-0.14.1/lib/pry/commands/whereami.rb:192 + def window_size; end + + class << self + # Returns the value of attribute method_size_cutoff. + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:15 + def method_size_cutoff; end + + # Sets the attribute method_size_cutoff + # + # @param value the value to set the attribute method_size_cutoff to. + # + # source://pry-0.14.1/lib/pry/commands/whereami.rb:15 + def method_size_cutoff=(_arg0); end + end +end + +# source://pry-0.14.1/lib/pry/commands/wtf.rb:5 +class Pry::Command::Wtf < ::Pry::ClassCommand + # source://pry-0.14.1/lib/pry/commands/wtf.rb:27 + def options(opt); end + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:32 + def process; end + + private + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:64 + def format_backtrace(backtrace); end + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:60 + def format_header(title, exception); end + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:83 + def read_line(file, line); end + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:76 + def trim_backtrace(backtrace); end + + # source://pry-0.14.1/lib/pry/commands/wtf.rb:48 + def unwind_exceptions; end +end + +# source://pry-0.14.1/lib/pry/commands/wtf.rb:25 +Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp) + +# CommandErrors are caught by the REPL loop and displayed to the user. They +# indicate an exceptional condition that's fatal to the current command. +# +# source://pry-0.14.1/lib/pry/exceptions.rb:68 +class Pry::CommandError < ::StandardError; end + +# This class is used to create sets of commands. Commands can be imported from +# different sets, aliased, removed, etc. +# +# source://pry-0.14.1/lib/pry/command_set.rb:12 +class Pry::CommandSet + include ::Enumerable + include ::Pry::Helpers::BaseHelpers + + # @param imported_sets [Array] Sets which will be imported automatically + # @return [CommandSet] a new instance of CommandSet + # @yield Optional block run to define commands + # + # source://pry-0.14.1/lib/pry/command_set.rb:20 + def initialize(*imported_sets, &block); end + + # Find a command that matches the given line + # + # @param pattern [String] The line that might be a command invocation + # @return [Pry::Command, nil] + # + # source://pry-0.14.1/lib/pry/command_set.rb:275 + def [](pattern); end + + # Re-assign the command found at _pattern_ with _command_. + # + # @example + # Pry.config.commands["help"] = MyHelpCommand + # @param pattern [Regexp, String] The command to add or replace(found at _pattern_). + # @param command [Pry::Command] The command to add. + # @return [Pry::Command] Returns the new command (matched with "pattern".) + # + # source://pry-0.14.1/lib/pry/command_set.rb:298 + def []=(pattern, command); end + + # Add a command to set. + # + # @param command [Command] a subclass of Pry::Command. + # + # source://pry-0.14.1/lib/pry/command_set.rb:324 + def add_command(command); end + + # Aliases a command + # + # @example Creating an alias for `ls -M` + # Pry.config.commands.alias_command "lM", "ls -M" + # @example Pass explicit description (overriding default). + # Pry.config.commands.alias_command "lM", "ls -M", :desc => "cutiepie" + # @param match [String, Regex] The match of the alias (can be a regex). + # @param action [String] The action to be performed (typically + # another command). + # @param options [Hash] The optional configuration parameters, + # accepts the same as the `command` method, but also allows the + # command description to be passed this way too as `:desc` + # + # source://pry-0.14.1/lib/pry/command_set.rb:190 + def alias_command(match, action, options = T.unsafe(nil)); end + + # Defines a new Pry command. + # + # @example + # MyCommands = Pry::CommandSet.new do + # command "greet", "Greet somebody" do |name| + # puts "Good afternoon #{name.capitalize}!" + # end + # end + # + # # From pry: + # # pry(main)> pry_instance.commands = MyCommands + # # pry(main)> greet john + # # Good afternoon John! + # # pry(main)> help greet + # # Greet somebody + # @example Regexp command + # MyCommands = Pry::CommandSet.new do + # command( + # /number-(\d+)/, "number-N regex command", :listing => "number" + # ) do |num, name| + # puts "hello #{name}, nice number: #{num}" + # end + # end + # + # # From pry: + # # pry(main)> pry_instance.commands = MyCommands + # # pry(main)> number-10 john + # # hello john, nice number: 10 + # # pry(main)> help number + # # number-N regex command + # @option options + # @option options + # @option options + # @option options + # @option options + # @param match [String, Regexp] The start of invocations of this command. + # @param description [String] A description of the command. + # @param options [Hash] The optional configuration parameters. + # @yield The action to perform. The parameters in the block + # determines the parameters the command will receive. All + # parameters passed into the block will be strings. Successive + # command parameters are separated by whitespace at the Pry prompt. + # + # source://pry-0.14.1/lib/pry/command_set.rb:78 + def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end + + # Defines a new Pry command. + # + # @example + # MyCommands = Pry::CommandSet.new do + # command "greet", "Greet somebody" do |name| + # puts "Good afternoon #{name.capitalize}!" + # end + # end + # + # # From pry: + # # pry(main)> pry_instance.commands = MyCommands + # # pry(main)> greet john + # # Good afternoon John! + # # pry(main)> help greet + # # Greet somebody + # @example Regexp command + # MyCommands = Pry::CommandSet.new do + # command( + # /number-(\d+)/, "number-N regex command", :listing => "number" + # ) do |num, name| + # puts "hello #{name}, nice number: #{num}" + # end + # end + # + # # From pry: + # # pry(main)> pry_instance.commands = MyCommands + # # pry(main)> number-10 john + # # hello john, nice number: 10 + # # pry(main)> help number + # # number-N regex command + # @option options + # @option options + # @option options + # @option options + # @option options + # @param match [String, Regexp] The start of invocations of this command. + # @param description [String] A description of the command. + # @param options [Hash] The optional configuration parameters. + # @yield The action to perform. The parameters in the block + # determines the parameters the command will receive. All + # parameters passed into the block will be strings. Successive + # command parameters are separated by whitespace at the Pry prompt. + # + # source://pry-0.14.1/lib/pry/command_set.rb:78 + def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end + + # Generate completions for the user's search. + # + # @param search [String] The line to search for + # @param context [Hash] The context to create the command with + # @return [Array] + # + # source://pry-0.14.1/lib/pry/command_set.rb:365 + def complete(search, context = T.unsafe(nil)); end + + # Defines a new Pry command class. + # + # @example + # Pry::Commands.create_command "echo", "echo's the input", :shellwords => false do + # def options(opt) + # opt.banner "Usage: echo [-u | -d] " + # opt.on :u, :upcase, "ensure the output is all upper-case" + # opt.on :d, :downcase, "ensure the output is all lower-case" + # end + # + # def process + # if opts.present?(:u) && opts.present?(:d) + # raise Pry::CommandError, "-u and -d makes no sense" + # end + # result = args.join(" ") + # result.downcase! if opts.present?(:downcase) + # result.upcase! if opts.present?(:upcase) + # output.puts result + # end + # end + # @param match [String, Regexp] The start of invocations of this command. + # @param description [String] A description of the command. + # @param options [Hash] The optional configuration parameters, see {#command} + # @yield The class body's definition. + # + # source://pry-0.14.1/lib/pry/command_set.rb:117 + def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end + + # Removes some commands from the set + # + # @param searches [Array] the matches or listings of the commands + # to remove + # + # source://pry-0.14.1/lib/pry/command_set.rb:138 + def delete(*searches); end + + # Sets or gets the description for a command (replacing the old + # description). Returns current description if no description + # parameter provided. + # + # @example Setting + # MyCommands = Pry::CommandSet.new do + # desc "help", "help description" + # end + # @example Getting + # Pry.config.commands.desc "amend-line" + # @param search [String, Regexp] The command match. + # @param description [String?] (nil) The command description. + # + # source://pry-0.14.1/lib/pry/command_set.rb:253 + def desc(search, description = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/command_set.rb:131 + def each(&block); end + + # Find a command that matches the given line + # + # @param pattern [String] The line that might be a command invocation + # @return [Pry::Command, nil] + # + # source://pry-0.14.1/lib/pry/command_set.rb:275 + def find_command(pattern); end + + # @param match_or_listing [String, Regexp] The match or listing of a command. + # of the command to retrieve. + # @return [Command] The command object matched. + # + # source://pry-0.14.1/lib/pry/command_set.rb:173 + def find_command_by_match_or_listing(match_or_listing); end + + # Find the command that the user might be trying to refer to. + # + # @param search [String] The user's search. + # @return [Pry::Command?] + # + # source://pry-0.14.1/lib/pry/command_set.rb:331 + def find_command_for_help(search); end + + # Returns the value of attribute helper_module. + # + # source://pry-0.14.1/lib/pry/command_set.rb:15 + def helper_module; end + + # Imports all the commands from one or more sets. + # + # @param sets [Array] Command sets, all of the commands of which + # will be imported. + # @return [Pry::CommandSet] Returns the reciever (a command set). + # + # source://pry-0.14.1/lib/pry/command_set.rb:149 + def import(*sets); end + + # Imports some commands from a set + # + # @param set [CommandSet] Set to import commands from + # @param matches [Array] Commands to import + # @return [Pry::CommandSet] Returns the reciever (a command set). + # + # source://pry-0.14.1/lib/pry/command_set.rb:161 + def import_from(set, *matches); end + + # @return [Array] The list of commands provided by the command set. + # + # source://pry-0.14.1/lib/pry/command_set.rb:262 + def keys; end + + # @return [Array] The list of commands provided by the command set. + # + # source://pry-0.14.1/lib/pry/command_set.rb:262 + def list_commands; end + + # Process the given line to see whether it needs executing as a command. + # + # @param val [String] The line to execute + # @param context [Hash] The context to execute the commands with + # @return [CommandSet::Result] + # + # source://pry-0.14.1/lib/pry/command_set.rb:351 + def process_line(val, context = T.unsafe(nil)); end + + # Rename a command. Accepts either match or listing for the search. + # + # @example Renaming the `ls` command and changing its description. + # Pry.config.commands.rename "dir", "ls", :description => "DOS friendly ls" + # @param new_match [String, Regexp] The new match for the command. + # @param search [String, Regexp] The command's current match or listing. + # @param options [Hash] The optional configuration parameters, + # accepts the same as the `command` method, but also allows the + # command description to be passed this way too. + # + # source://pry-0.14.1/lib/pry/command_set.rb:227 + def rename_command(new_match, search, options = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/command_set.rb:267 + def to_h; end + + # source://pry-0.14.1/lib/pry/command_set.rb:267 + def to_hash; end + + # Is the given line a command invocation? + # + # @param val [String] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/command_set.rb:343 + def valid_command?(val); end + + private + + # Defines helpers methods for this command sets. + # Those helpers are only defined in this command set. + # + # @example + # helpers do + # def hello + # puts "Hello!" + # end + # + # include OtherModule + # end + # @yield A block defining helper methods + # + # source://pry-0.14.1/lib/pry/command_set.rb:390 + def helpers(&block); end +end + +# CommandState is a data structure to hold per-command state. +# +# Pry commands can store arbitrary state here. This state persists between +# subsequent command invocations. All state saved here is unique to the +# command. +# +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/command_state.rb:14 +class Pry::CommandState + # @api private + # @return [CommandState] a new instance of CommandState + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/command_state.rb:19 + def initialize; end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/command_state.rb:27 + def reset(command_name); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/command_state.rb:23 + def state_for(command_name); end + + class << self + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/command_state.rb:15 + def default; end + end +end + +# source://pry-0.14.1/lib/pry.rb:35 +Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet) + +# @api private +# +# source://pry-0.14.1/lib/pry/config/attributable.rb:4 +class Pry::Config + extend ::Pry::Config::Attributable + + # @api private + # @return [Config] a new instance of Config + # + # source://pry-0.14.1/lib/pry/config.rb:154 + def initialize; end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:234 + def [](attr); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:230 + def []=(attr, value); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def auto_indent; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def auto_indent=(_arg0); end + + # @api private + # @return [Boolean] whether or not display a warning when a command name + # collides with a method/local in the current context. + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def collision_warning; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def collision_warning=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def color; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def color=(_arg0); end + + # @api private + # @return [Proc] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def command_completions; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def command_completions=(_arg0); end + + # A string that must precede all commands. For example, if is is + # set to "%", the "cd" command must be invoked as "%cd"). + # + # @api private + # @return [String] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def command_prefix; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def command_prefix=(_arg0); end + + # @api private + # @return [Pry::CommandSet] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def commands; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def commands=(_arg0); end + + # @api private + # @return [#build_completion_proc] a completer to use + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def completer; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def completer=(_arg0); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:259 + def control_d_handler; end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:260 + def control_d_handler=(value); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def correct_indent; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def correct_indent=(_arg0); end + + # @api private + # @return [Integer] The number of lines of context to show before and after + # exceptions + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def default_window_size; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def default_window_size=(_arg0); end + + # @api private + # @return [Boolean] whether to disable edit-method's auto-reloading behavior + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def disable_auto_reload; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def disable_auto_reload=(_arg0); end + + # If it is a String, then that String is used as the shell + # command to invoke the editor. + # + # If it responds to #call is callable then `file`, `line`, and `reloading` + # are passed to it. `reloading` indicates whether Pry will be reloading code + # after the shell command returns. All parameters are optional. + # + # @api private + # @return [String, #call] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def editor; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def editor=(_arg0); end + + # @api private + # @return [Proc] the printer for exceptions + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def exception_handler; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def exception_handler=(_arg0); end + + # @api private + # @deprecated + # @return [Array] Exception that Pry shouldn't rescue + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def exception_whitelist; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def exception_whitelist=(_arg0); end + + # @api private + # @return [String] a line of code to execute in context before the session + # starts + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def exec_string; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def exec_string=(_arg0); end + + # @api private + # @return [Hash{Symbol=>Proc}] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def extra_sticky_locals; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def extra_sticky_locals=(_arg0); end + + # @api private + # @return [Proc] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def file_completions; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def file_completions=(_arg0); end + + # @api private + # @return [Pry::History] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def history; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def history=(_arg0); end + + # @api private + # @return [String] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def history_file; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def history_file=(_arg0); end + + # @api private + # @return [Array] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def history_ignorelist; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def history_ignorelist=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def history_load; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def history_load=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def history_save; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def history_save=(_arg0); end + + # @api private + # @return [Pry::Hooks] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def hooks; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def hooks=(_arg0); end + + # @api private + # @return [IO, #readline] he object from which Pry retrieves its lines of + # input + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def input; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def input=(_arg0); end + + # @api private + # @return [Hash] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def ls; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def ls=(_arg0); end + + # @api private + # @return [Integer] how many input/output lines to keep in memory + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def memory_size; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def memory_size=(_arg0); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:226 + def merge(config_hash); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:221 + def merge!(config_hash); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:239 + def method_missing(method_name, *args, &_block); end + + # @api private + # @return [IO, #puts] where Pry should output results provided by {input} + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def output; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def output=(_arg0); end + + # @api private + # @return [String] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def output_prefix; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def output_prefix=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def pager; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def pager=(_arg0); end + + # @api private + # @return [Proc] the printer for Ruby expressions (not commands) + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def print; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def print=(_arg0); end + + # @api private + # @return [Pry::Prompt] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def prompt; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def prompt=(_arg0); end + + # @api private + # @return [String] The display name that is part of the prompt + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def prompt_name; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def prompt_name=(_arg0); end + + # @api private + # @return [Array] the list of objects that are known to have a + # 1-line #inspect output suitable for prompt + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def prompt_safe_contexts; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def prompt_safe_contexts=(_arg0); end + + # @api private + # @return [Boolean] suppresses whereami output on `binding.pry` + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def quiet; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def quiet=(_arg0); end + + # @api private + # @return [String] + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def rc_file; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def rc_file=(_arg0); end + + # @api private + # @return [Array] Ruby files to be required + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def requires; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def requires=(_arg0); end + + # @api private + # @return [Boolean] whether the local ./.pryrc should be loaded + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def should_load_local_rc; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def should_load_local_rc=(_arg0); end + + # @api private + # @return [Boolean] whether the global ~/.pryrc should be loaded + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def should_load_rc; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def should_load_rc=(_arg0); end + + # @api private + # @return [Boolean] whether to load files specified with the -r flag + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def should_load_requires; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def should_load_requires=(_arg0); end + + # Whether Pry should trap SIGINT and cause it to raise an Interrupt + # exception. This is only useful on JRuby, MRI does this for us. + # + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def should_trap_interrupts; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def should_trap_interrupts=(_arg0); end + + # @api private + # @return [Proc] The proc that runs system commands + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def system; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def system=(_arg0); end + + # @api private + # @return [Array] Exception that Pry shouldn't rescue + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def unrescued_exceptions; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def unrescued_exceptions=(_arg0); end + + # @api private + # @return [Boolean] displays a warning about experience improvement on + # Windows + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:13 + def windows_console_warning; end + + # source://pry-0.14.1/lib/pry/config/attributable.rb:18 + def windows_console_warning=(_arg0); end + + private + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:303 + def default_rc_file; end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:254 + def initialize_dup(other); end + + # @api private + # + # source://pry-0.14.1/lib/pry/config.rb:289 + def lazy_readline; end + + # @api private + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/config.rb:250 + def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end +end + +# Attributable provides the ability to create "attribute" +# accessors. Attribute accessors create a standard "attr_writer" and a +# customised "attr_reader". This reader is Proc-aware (lazy). +# +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/config/attributable.rb:11 +module Pry::Config::Attributable + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/attributable.rb:12 + def attribute(attr_name); end +end + +# LazyValue is a Proc (block) wrapper. It is meant to be used as a +# configuration value. Subsequent `#call` calls always evaluate the given +# block. +# +# @api private +# @example +# num = 19 +# value = Pry::Config::LazyValue.new { num += 1 } +# value.foo # => 20 +# value.foo # => 21 +# value.foo # => 22 +# @see Pry::Config::MemoizedValue +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/config/lazy_value.rb:19 +class Pry::Config::LazyValue + # @api private + # @return [LazyValue] a new instance of LazyValue + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/lazy_value.rb:20 + def initialize(&block); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/lazy_value.rb:24 + def call; end +end + +# MemoizedValue is a Proc (block) wrapper. It is meant to be used as a +# configuration value. Subsequent `#call` calls return the same memoized +# result. +# +# @api private +# @example +# num = 19 +# value = Pry::Config::MemoizedValue.new { num += 1 } +# value.call # => 20 +# value.call # => 20 +# value.call # => 20 +# @see Pry::Config::LazyValue +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/config/memoized_value.rb:19 +class Pry::Config::MemoizedValue + # @api private + # @return [MemoizedValue] a new instance of MemoizedValue + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/memoized_value.rb:20 + def initialize(&block); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/memoized_value.rb:26 + def call; end +end + +# Value holds a value for the given attribute and decides how it should +# be read. Procs get called, other values are returned as is. +# +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/config/value.rb:10 +class Pry::Config::Value + # @api private + # @return [Value] a new instance of Value + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/value.rb:11 + def initialize(value); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/config/value.rb:15 + def call; end +end + +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/control_d_handler.rb:6 +module Pry::ControlDHandler + class << self + # Deal with the ^D key being pressed. Different behaviour in different + # cases: + # 1. In an expression behave like `!` command. + # 2. At top-level session behave like `exit` command. + # 3. In a nested session behave like `cd ..`. + # + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/control_d_handler.rb:12 + def default(pry_instance); end + end +end + +# source://pry-0.14.1/lib/pry/pry_instance.rb:59 +Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/editor.rb:6 +class Pry::Editor + include ::Pry::Helpers::OptionsHelpers + include ::Pry::Helpers::CommandHelpers + + # @return [Editor] a new instance of Editor + # + # source://pry-0.14.1/lib/pry/editor.rb:27 + def initialize(pry_instance); end + + # Generate the string that's used to start the editor. This includes + # all the flags we want as well as the file and line number we + # want to open at. + # + # source://pry-0.14.1/lib/pry/editor.rb:60 + def build_editor_invocation_string(file, line, blocking); end + + # source://pry-0.14.1/lib/pry/editor.rb:31 + def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/editor.rb:41 + def invoke_editor(file, line, blocking = T.unsafe(nil)); end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/editor.rb:25 + def pry_instance; end + + private + + # Some editors that run outside the terminal allow you to control whether or + # not to block the process from which they were launched (in this case, Pry). + # For those editors, return the flag that produces the desired behavior. + # + # source://pry-0.14.1/lib/pry/editor.rb:100 + def blocking_flag_for_editor(blocking); end + + # Get the name of the binary that Pry.config.editor points to. + # + # This is useful for deciding which flags we pass to the editor as + # we can just use the program's name and ignore any absolute paths. + # + # @example + # Pry.config.editor="/home/conrad/bin/textmate -w" + # editor_name + # # => textmate + # + # source://pry-0.14.1/lib/pry/editor.rb:151 + def editor_name; end + + # Start the editor running, using the calculated invocation string + # + # source://pry-0.14.1/lib/pry/editor.rb:76 + def open_editor(editor_invocation); end + + # We need JRuby specific code here cos just shelling out using + # system() appears to be pretty broken :/ + # + # source://pry-0.14.1/lib/pry/editor.rb:89 + def open_editor_on_jruby(editor_invocation); end + + # Return the syntax for a given editor for starting the editor + # and moving to a particular line within that file + # + # source://pry-0.14.1/lib/pry/editor.rb:115 + def start_line_syntax_for_editor(file_name, line_number); end + + class << self + # source://pry-0.14.1/lib/pry/editor.rb:7 + def default; end + end +end + +# Env is a helper module to work with environment variables. +# +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/env.rb:8 +module Pry::Env + class << self + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/env.rb:9 + def [](key); end + end +end + +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/exception_handler.rb:6 +module Pry::ExceptionHandler + class << self + # Will only show the first line of the backtrace. + # + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/exception_handler.rb:9 + def handle_exception(output, exception, _pry_instance); end + + private + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/exception_handler.rb:37 + def cause_text(cause); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/exception_handler.rb:32 + def exception_text(exception); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/exception_handler.rb:19 + def standard_error_text_for(exception); end + end +end + +# source://pry-0.14.1/lib/pry/forwardable.rb:4 +module Pry::Forwardable + include ::Forwardable + + # Since Ruby 2.4, Forwardable will print a warning when + # calling a method that is private on a delegate, and + # in the future it could be an error: https://bugs.ruby-lang.org/issues/12782#note-3 + # + # That's why we revert to a custom implementation for delegating one + # private method to another. + # + # source://pry-0.14.1/lib/pry/forwardable.rb:16 + def def_private_delegators(target, *private_delegates); end +end + +# When we try to get a binding for an object, we try to define a method on +# that Object's singleton class. This doesn't work for "frozen" Object's, and +# the exception is just a vanilla RuntimeError. +# +# source://pry-0.14.1/lib/pry/exceptions.rb:56 +module Pry::FrozenObjectException + class << self + # source://pry-0.14.1/lib/pry/exceptions.rb:57 + def ===(exception); end + end +end + +# source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:4 +module Pry::Helpers + class << self + # source://pry-0.14.1/lib/pry/helpers/table.rb:27 + def tablify(things, line_length, pry_instance = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:5 + def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:16 + def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end + end +end + +# source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:5 +module Pry::Helpers::BaseHelpers + extend ::Pry::Helpers::BaseHelpers + + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:43 + def colorize_code(code); end + + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:27 + def find_command(name, set = T.unsafe(nil)); end + + # formatting + # + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:54 + def heading(text); end + + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:47 + def highlight(string, regexp, highlight_color = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:34 + def not_a_real_file?(file); end + + # Acts like send but ignores any methods defined below Object or Class in the + # inheritance hierarchy. + # This is required to introspect methods on objects like Net::HTTP::Get that + # have overridden the `method` method. + # + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:22 + def safe_send(obj, method, *args, &block); end + + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:8 + def silence_warnings; end + + # Send the given text through the best available pager (if Pry.config.pager is + # enabled). Infers where to send the output if used as a mixin. + # DEPRECATED. + # + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:62 + def stagger_output(text, _out = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/helpers/base_helpers.rb:38 + def use_ansi_codes?; end +end + +# source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:7 +module Pry::Helpers::CommandHelpers + include ::Pry::Helpers::OptionsHelpers + extend ::Pry::Helpers::OptionsHelpers + extend ::Pry::Helpers::CommandHelpers + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:115 + def absolute_index_number(line_number, array_length); end + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:123 + def absolute_index_range(range_or_number, array_length); end + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:31 + def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:21 + def internal_binding?(context); end + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:97 + def one_index_number(line_number); end + + # convert a 1-index range to a 0-indexed one + # + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:102 + def one_index_range(range); end + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:106 + def one_index_range_or_number(range_or_number); end + + # Restrict a string to the given range of lines (1-indexed) + # + # @param content [String] The string. + # @param lines [Range, Integer] The line(s) to restrict it to. + # @return [String] The resulting string. + # + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:92 + def restrict_to_lines(content, lines); end + + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:135 + def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end + + # Open a temp file and yield it to the block, closing it after + # + # @return [String] The path of the temp file + # + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:14 + def temp_file(ext = T.unsafe(nil)); end + + # Remove any common leading whitespace from every line in `text`. This + # can be used to make a HEREDOC line up with the left margin, without + # sacrificing the indentation level of the source code. + # + # @example + # opt.banner(unindent(<<-USAGE)) + # Lorem ipsum dolor sit amet, consectetur adipisicing elit, + # sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. + # "Ut enim ad minim veniam." + # USAGE + # @param dirty_text [String] The text from which to remove indentation + # @return [String] the text with indentation stripped + # + # source://pry-0.14.1/lib/pry/helpers/command_helpers.rb:68 + def unindent(dirty_text, left_padding = T.unsafe(nil)); end +end + +# This class contains methods useful for extracting +# documentation from methods and classes. +# +# source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:7 +module Pry::Helpers::DocumentationHelpers + private + + # Given a string that makes up a comment in a source-code file parse out the content + # that the user is intended to read. (i.e. without leading indentation, #-characters + # or shebangs) + # + # @param comment [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:67 + def get_comment_content(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:51 + def process_comment_markup(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:15 + def process_rdoc(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:45 + def process_yardoc(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:30 + def process_yardoc_tag(comment, tag); end + + # @param code [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:57 + def strip_comments_from_c_code(code); end + + # @param text [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:79 + def strip_leading_whitespace(text); end + + class << self + # Given a string that makes up a comment in a source-code file parse out the content + # that the user is intended to read. (i.e. without leading indentation, #-characters + # or shebangs) + # + # @param comment [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:67 + def get_comment_content(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:51 + def process_comment_markup(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:15 + def process_rdoc(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:45 + def process_yardoc(comment); end + + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:30 + def process_yardoc_tag(comment, tag); end + + # @param code [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:57 + def strip_comments_from_c_code(code); end + + # @param text [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:79 + def strip_leading_whitespace(text); end + end +end + +# source://pry-0.14.1/lib/pry/helpers/documentation_helpers.rb:8 +Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/helpers/options_helpers.rb:5 +module Pry::Helpers::OptionsHelpers + private + + # Get the method object parsed by the slop instance + # + # source://pry-0.14.1/lib/pry/helpers/options_helpers.rb:23 + def method_object; end + + # Add method options to the Pry::Slop instance + # + # source://pry-0.14.1/lib/pry/helpers/options_helpers.rb:9 + def method_options(opt); end + + class << self + # Get the method object parsed by the slop instance + # + # source://pry-0.14.1/lib/pry/helpers/options_helpers.rb:23 + def method_object; end + + # Add method options to the Pry::Slop instance + # + # source://pry-0.14.1/lib/pry/helpers/options_helpers.rb:9 + def method_options(opt); end + end +end + +# Contains methods for querying the platform that Pry is running on +# +# @api public +# @since v0.12.0 +# +# source://pry-0.14.1/lib/pry/helpers/platform.rb:10 +module Pry::Helpers::Platform + class << self + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:35 + def jruby?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:40 + def jruby_19?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:17 + def linux?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:12 + def mac_osx?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:45 + def mri?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:50 + def mri_19?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:55 + def mri_2?; end + + # @api public + # @return [Boolean] true when Pry is running on Windows with ANSI support, + # false otherwise + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:23 + def windows?; end + + # @api public + # @return [Boolean] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/helpers/platform.rb:28 + def windows_ansi?; end + end +end + +# source://pry-0.14.1/lib/pry/helpers/table.rb:35 +class Pry::Helpers::Table + # @return [Table] a new instance of Table + # + # source://pry-0.14.1/lib/pry/helpers/table.rb:37 + def initialize(items, args, pry_instance = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:81 + def ==(other); end + + # Returns the value of attribute column_count. + # + # source://pry-0.14.1/lib/pry/helpers/table.rb:36 + def column_count; end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:68 + def column_count=(count); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:77 + def columns; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/helpers/table.rb:73 + def fits_on_line?(line_length); end + + # Returns the value of attribute items. + # + # source://pry-0.14.1/lib/pry/helpers/table.rb:36 + def items; end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:62 + def items=(items); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:47 + def rows_to_s(style = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:85 + def to_a; end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:43 + def to_s; end + + private + + # source://pry-0.14.1/lib/pry/helpers/table.rb:91 + def _max_width(things); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:95 + def _rebuild_colorless_cache; end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:116 + def _recall_color_for(thing); end + + # source://pry-0.14.1/lib/pry/helpers/table.rb:105 + def _recolumn; end +end + +# The methods defined on {Text} are available to custom commands via +# {Pry::Command#text}. +# +# source://pry-0.14.1/lib/pry/helpers/text.rb:7 +module Pry::Helpers::Text + extend ::Pry::Helpers::Text + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def black_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def blue_on_yellow(text); end + + # Returns _text_ as bold text for use on a terminal. + # + # @param text [String, #to_s] + # @return [String] _text_ + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:54 + def bold(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_black_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_blue_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_cyan_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_green_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_magenta_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_purple_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_red_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_white_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:27 + def bright_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:36 + def bright_yellow_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def cyan_on_yellow(text); end + + # Returns `text` in the default foreground colour. + # Use this instead of "black" or "white" when you mean absence of colour. + # + # @param text [String, #to_s] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:63 + def default(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def green_on_yellow(text); end + + # Returns _text_ indented by _chars_ spaces. + # + # @param text [String] + # @param chars [Fixnum] + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:113 + def indent(text, chars); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def magenta_on_yellow(text); end + + # @return [void] + # @yield Yields a block with color turned off. + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:73 + def no_color; end + + # @return [void] + # @yield Yields a block with paging turned off. + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:87 + def no_pager; end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def purple_on_yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def red_on_yellow(text); end + + # Remove any color codes from _text_. + # + # @param text [String, #to_s] + # @return [String] _text_ stripped of any color codes. + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:46 + def strip_color(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def white_on_yellow(text); end + + # Returns _text_ in a numbered list, beginning at _offset_. + # + # @param text [#each_line] + # @param offset [Fixnum] + # @return [String] + # + # source://pry-0.14.1/lib/pry/helpers/text.rb:100 + def with_line_numbers(text, offset, color = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:23 + def yellow(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_black(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_blue(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_cyan(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_green(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_magenta(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_purple(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_red(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_white(text); end + + # source://pry-0.14.1/lib/pry/helpers/text.rb:32 + def yellow_on_yellow(text); end +end + +# source://pry-0.14.1/lib/pry/helpers/text.rb:10 +Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash) + +# The History class is responsible for maintaining the user's input history, +# both internally and within Readline. +# +# source://pry-0.14.1/lib/pry/history.rb:6 +class Pry::History + # @return [History] a new instance of History + # + # source://pry-0.14.1/lib/pry/history.rb:29 + def initialize(options = T.unsafe(nil)); end + + # Add a line to the input history, ignoring blank and duplicate lines. + # + # @param line [String] + # @return [String] The same line that was passed in + # + # source://pry-0.14.1/lib/pry/history.rb:53 + def <<(line); end + + # Clear this session's history. This won't affect the contents of the + # history file. + # + # source://pry-0.14.1/lib/pry/history.rb:74 + def clear; end + + # Filter the history with the histignore options + # + # @return [Array] An array containing all the lines that are not + # included in the histignore. + # + # source://pry-0.14.1/lib/pry/history.rb:95 + def filter(history); end + + # @return [Integer] total number of lines, including original lines + # + # source://pry-0.14.1/lib/pry/history.rb:27 + def history_line_count; end + + # Load the input history using `History.loader`. + # + # @return [Integer] The number of lines loaded + # + # source://pry-0.14.1/lib/pry/history.rb:40 + def load; end + + # Returns the value of attribute loader. + # + # source://pry-0.14.1/lib/pry/history.rb:21 + def loader; end + + # Sets the attribute loader + # + # @param value the value to set the attribute loader to. + # + # source://pry-0.14.1/lib/pry/history.rb:21 + def loader=(_arg0); end + + # @return [Fixnum] Number of lines in history when Pry first loaded. + # + # source://pry-0.14.1/lib/pry/history.rb:24 + def original_lines; end + + # Add a line to the input history, ignoring blank and duplicate lines. + # + # @param line [String] + # @return [String] The same line that was passed in + # + # source://pry-0.14.1/lib/pry/history.rb:53 + def push(line); end + + # Returns the value of attribute saver. + # + # source://pry-0.14.1/lib/pry/history.rb:21 + def saver; end + + # Sets the attribute saver + # + # @param value the value to set the attribute saver to. + # + # source://pry-0.14.1/lib/pry/history.rb:21 + def saver=(_arg0); end + + # @return [Fixnum] The number of lines in history from just this session. + # + # source://pry-0.14.1/lib/pry/history.rb:81 + def session_line_count; end + + # Return an Array containing all stored history. + # + # @return [Array] An Array containing all lines of history loaded + # or entered by the user in the current session. + # + # source://pry-0.14.1/lib/pry/history.rb:88 + def to_a; end + + private + + # The history file, opened for appending. + # + # source://pry-0.14.1/lib/pry/history.rb:127 + def history_file; end + + # source://pry-0.14.1/lib/pry/history.rb:143 + def history_file_path; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/history.rb:147 + def invalid_readline_line?(line); end + + # The default loader. Yields lines from `Pry.config.history_file`. + # + # source://pry-0.14.1/lib/pry/history.rb:113 + def read_from_file; end + + # The default saver. Appends the given line to `Pry.config.history_file`. + # + # source://pry-0.14.1/lib/pry/history.rb:122 + def save_to_file(line); end + + # Check if the line match any option in the histignore + # [Pry.config.history_ignorelist] + # + # @return [Boolean] a boolean that notifies if the line was found in the + # histignore array. + # + # source://pry-0.14.1/lib/pry/history.rb:105 + def should_ignore?(line); end + + class << self + # source://pry-0.14.1/lib/pry/history.rb:7 + def default_file; end + end +end + +# Implements a hooks system for Pry. A hook is a callable that is associated +# with an event. A number of events are currently provided by Pry, these +# include: `:when_started`, `:before_session`, `:after_session`. A hook must +# have a name, and is connected with an event by the `Pry::Hooks#add_hook` +# method. +# +# @example Adding a hook for the `:before_session` event. +# Pry.config.hooks.add_hook(:before_session, :say_hi) do +# puts "hello" +# end +# +# source://pry-0.14.1/lib/pry/hooks.rb:14 +class Pry::Hooks + # @return [Hooks] a new instance of Hooks + # + # source://pry-0.14.1/lib/pry/hooks.rb:25 + def initialize; end + + # Add a new hook to be executed for the `event_name` event. + # + # @param event_name [Symbol] The name of the event. + # @param hook_name [Symbol] The name of the hook. + # @param callable [#call] The callable. + # @raise [ArgumentError] + # @return [Pry:Hooks] The receiver. + # @yield The block to use as the callable (if no `callable` provided). + # + # source://pry-0.14.1/lib/pry/hooks.rb:81 + def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end + + # Clear all hooks functions for a given event. + # + # @param event_name [String] The name of the event. + # @return [void] + # + # source://pry-0.14.1/lib/pry/hooks.rb:165 + def clear_event_hooks(event_name); end + + # @param event_name [Symbol] The name of the event. + # @param hook_name [Symbol] The name of the hook. + # to delete. + # @return [#call] The deleted hook. + # + # source://pry-0.14.1/lib/pry/hooks.rb:147 + def delete_hook(event_name, hook_name); end + + # source://pry-0.14.1/lib/pry/hooks.rb:39 + def errors; end + + # Execute the list of hooks for the `event_name` event. + # + # @param event_name [Symbol] The name of the event. + # @param args [Array] The arguments to pass to each hook function. + # @return [Object] The return value of the last executed hook. + # + # source://pry-0.14.1/lib/pry/hooks.rb:108 + def exec_hook(event_name, *args, &block); end + + # @param event_name [Symbol] The name of the event. + # @param hook_name [Symbol] The name of the hook + # @return [#call] a specific hook for a given event. + # + # source://pry-0.14.1/lib/pry/hooks.rb:128 + def get_hook(event_name, hook_name); end + + # `add_hook`/`delete_hook` for that. + # + # @note Modifying the returned hash does not alter the hooks, use + # @param event_name [Symbol] The name of the event. + # @return [Hash] The hash of hook names / hook functions. + # + # source://pry-0.14.1/lib/pry/hooks.rb:139 + def get_hooks(event_name); end + + # @param event_name [Symbol] The name of the event. + # @return [Fixnum] The number of hook functions for `event_name`. + # + # source://pry-0.14.1/lib/pry/hooks.rb:121 + def hook_count(event_name); end + + # @param event_name [Symbol] Name of the event. + # @param hook_name [Symbol] Name of the hook. + # @return [Boolean] Whether the hook by the name `hook_name`. + # + # source://pry-0.14.1/lib/pry/hooks.rb:172 + def hook_exists?(event_name, hook_name); end + + # @example + # hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" } + # Pry::Hooks.new.merge(hooks) + # @param other [Pry::Hooks] The `Pry::Hooks` instance to merge + # @return [Pry::Hooks] a new `Pry::Hooks` instance containing a merge of the + # contents of two `Pry:Hooks` instances. + # + # source://pry-0.14.1/lib/pry/hooks.rb:69 + def merge(other); end + + # Destructively merge the contents of two `Pry:Hooks` instances. + # + # @param other [Pry::Hooks] The `Pry::Hooks` instance to merge + # @return [Pry:Hooks] The receiver. + # @see #merge + # + # source://pry-0.14.1/lib/pry/hooks.rb:48 + def merge!(other); end + + protected + + # Returns the value of attribute hooks. + # + # source://pry-0.14.1/lib/pry/hooks.rb:178 + def hooks; end + + private + + # Ensure that duplicates have their @hooks object. + # + # source://pry-0.14.1/lib/pry/hooks.rb:30 + def initialize_copy(_orig); end + + class << self + # source://pry-0.14.1/lib/pry/hooks.rb:15 + def default; end + end +end + +# Pry::Indent is a class that can be used to indent a number of lines +# containing Ruby code similar as to how IRB does it (but better). The class +# works by tokenizing a string using CodeRay and then looping over those +# tokens. Based on the tokens in a line of code that line (or the next one) +# will be indented or un-indented by correctly. +# +# source://pry-0.14.1/lib/pry/indent.rb:11 +class Pry::Indent + include ::Pry::Helpers::BaseHelpers + + # @return [Indent] a new instance of Indent + # + # source://pry-0.14.1/lib/pry/indent.rb:104 + def initialize(pry_instance = T.unsafe(nil)); end + + # Return a string which, when printed, will rewrite the previous line with + # the correct indentation. Mostly useful for fixing 'end'. + # + # @param prompt [String] The user's prompt + # @param code [String] The code the user just typed in + # @param overhang [Integer] The number of characters to erase afterwards (the + # the difference in length between the old line and the new one) + # @return [String] correctly indented line + # + # source://pry-0.14.1/lib/pry/indent.rb:393 + def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end + + # Get the indentation for the start of the next line. + # + # This is what's used between the prompt and the cursor in pry. + # + # @return String The correct number of spaces + # + # source://pry-0.14.1/lib/pry/indent.rb:181 + def current_prefix; end + + # If the code just before an "if" or "while" token on a line looks like the + # end of a statement, then we want to treat that "if" as a singleline, not + # multiline statement. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/indent.rb:264 + def end_of_statement?(last_token, last_kind); end + + # Are we currently in the middle of a string literal. + # + # This is used to determine whether to re-indent a given line, we mustn't + # re-indent within string literals because to do so would actually change + # the value of the String! + # + # @return [Boolean] Boolean + # + # source://pry-0.14.1/lib/pry/indent.rb:275 + def in_string?; end + + # Indents a string and returns it. This string can either be a single line + # or multiple ones. + # + # @example + # str = <] + # + # source://pry-0.14.1/lib/pry/indent.rb:376 + def module_nesting; end + + # All the open delimiters, in the order that they first appeared. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/indent.rb:312 + def open_delimiters; end + + # Return a string which restores the CodeRay string status to the correct value by + # opening HEREDOCs and strings. + # + # @return String + # + # source://pry-0.14.1/lib/pry/indent.rb:320 + def open_delimiters_line; end + + # reset internal state + # + # source://pry-0.14.1/lib/pry/indent.rb:110 + def reset; end + + # @return [Array] The stack of open tokens. + # + # source://pry-0.14.1/lib/pry/indent.rb:21 + def stack; end + + # Given a string of Ruby code, use CodeRay to export the tokens. + # + # @param string [String] The Ruby to lex + # @return [Array] An Array of pairs of [token_value, token_type] + # + # source://pry-0.14.1/lib/pry/indent.rb:283 + def tokenize(string); end + + # Update the internal state about what kind of strings are open. + # + # Most of the complication here comes from the fact that HEREDOCs can be + # nested. For normal strings (which can't be nested) we assume that CodeRay + # correctly pairs open-and-close delimiters so we don't bother checking what + # they are. + # + # @param token [String] The token (of type :delimiter) + # + # source://pry-0.14.1/lib/pry/indent.rb:297 + def track_delimiter(token); end + + # Update the internal state relating to module nesting. + # + # It's responsible for adding to the @module_nesting array, which looks + # something like: + # + # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ] + # + # A nil value in the @module_nesting array happens in two places: either + # when @awaiting_class is true and we're still waiting for the string to + # fill that space, or when a parse was rejected. + # + # At the moment this function is quite restricted about what formats it will + # parse, for example we disallow expressions after the class keyword. This + # could maybe be improved in the future. + # + # @param token [String] a token from Coderay + # @param kind [Symbol] the kind of that token + # + # source://pry-0.14.1/lib/pry/indent.rb:341 + def track_module_nesting(token, kind); end + + # Update the internal state relating to module nesting on 'end'. + # + # If the current 'end' pairs up with a class or a module then we should + # pop an array off of @module_nesting + # + # @param token [String] a token from Coderay + # @param kind [Symbol] the kind of that token + # + # source://pry-0.14.1/lib/pry/indent.rb:366 + def track_module_nesting_end(token, kind = T.unsafe(nil)); end + + class << self + # Clean the indentation of a fragment of ruby. + # + # @param str [String] + # @return [String] + # + # source://pry-0.14.1/lib/pry/indent.rb:82 + def indent(str); end + + # Get the module nesting at the given point in the given string. + # + # NOTE If the line specified contains a method definition, then the nesting + # at the start of the method definition is used. Otherwise the nesting from + # the end of the line is used. + # + # @param str [String] The ruby code to analyze + # @param line_number [Fixnum] The line number (starting from 1) + # @return [Array] + # + # source://pry-0.14.1/lib/pry/indent.rb:95 + def nesting_at(str, line_number); end + end +end + +# Collection of token types that should be ignored. Without this list +# keywords such as "class" inside strings would cause the code to be +# indented incorrectly. +# +# :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0 +# classifications of "true", "false", and "nil". +# +# source://pry-0.14.1/lib/pry/indent.rb:60 +Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array) + +# Collection of tokens that should appear dedented even though they +# don't affect the surrounding code. +# +# source://pry-0.14.1/lib/pry/indent.rb:76 +Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array) + +# Hash containing all the tokens that should increase the indentation +# level. The keys of this hash are open tokens, the values the matching +# tokens that should prevent a line from being indented if they appear on +# the same line. +# +# source://pry-0.14.1/lib/pry/indent.rb:30 +Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash) + +# Which tokens can be followed by an optional "do" keyword. +# +# source://pry-0.14.1/lib/pry/indent.rb:52 +Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array) + +# Which tokens can either be open tokens, or appear as modifiers on +# a single-line. +# +# source://pry-0.14.1/lib/pry/indent.rb:49 +Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array) + +# The amount of spaces to insert for each indent level. +# +# source://pry-0.14.1/lib/pry/indent.rb:24 +Pry::Indent::SPACES = T.let(T.unsafe(nil), String) + +# Tokens that indicate the end of a statement (i.e. that, if they appear +# directly before an "if" indicates that that if applies to the same line, +# not the next line) +# +# :reserved and :keywords are the CodeRay 0.9.8 and 1.0.0 respectively +# classifications of "super", "next", "return", etc. +# +# source://pry-0.14.1/lib/pry/indent.rb:69 +Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array) + +# Raised if {#module_nesting} would not work. +# +# source://pry-0.14.1/lib/pry/indent.rb:15 +class Pry::Indent::UnparseableNestingError < ::StandardError; end + +# source://pry-0.14.1/lib/pry/input_completer.rb:6 +class Pry::InputCompleter + # @return [InputCompleter] a new instance of InputCompleter + # + # source://pry-0.14.1/lib/pry/input_completer.rb:42 + def initialize(input, pry = T.unsafe(nil)); end + + # build_path seperates the input into two parts: path and input. + # input is the partial string that should be completed + # path is a proc that takes an input and builds a full path. + # + # source://pry-0.14.1/lib/pry/input_completer.rb:240 + def build_path(input); end + + # Return a new completion proc for use by Readline. + # + # source://pry-0.14.1/lib/pry/input_completer.rb:56 + def call(str, options = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/input_completer.rb:255 + def ignored_modules; end + + # source://pry-0.14.1/lib/pry/input_completer.rb:229 + def select_message(path, receiver, message, candidates); end +end + +# source://pry-0.14.1/lib/pry/input_completer.rb:8 +Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:15 +Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:14 +Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:17 +Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:16 +Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:7 +Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:12 +Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:11 +Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:20 +Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/input_completer.rb:10 +Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:9 +Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:13 +Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:18 +Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://pry-0.14.1/lib/pry/input_completer.rb:40 +Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String) + +# There is one InputLock per input (such as STDIN) as two REPLs on the same +# input makes things delirious. InputLock serializes accesses to the input so +# that threads to not conflict with each other. The latest thread to request +# ownership of the input wins. +# +# source://pry-0.14.1/lib/pry/input_lock.rb:8 +class Pry::InputLock + # @return [InputLock] a new instance of InputLock + # + # source://pry-0.14.1/lib/pry/input_lock.rb:29 + def initialize; end + + # Adds ourselves to the ownership list. The last one in the list may access + # the input through interruptible_region(). + # + # source://pry-0.14.1/lib/pry/input_lock.rb:38 + def __with_ownership; end + + # source://pry-0.14.1/lib/pry/input_lock.rb:81 + def enter_interruptible_region; end + + # source://pry-0.14.1/lib/pry/input_lock.rb:108 + def interruptible_region; end + + # source://pry-0.14.1/lib/pry/input_lock.rb:95 + def leave_interruptible_region; end + + # source://pry-0.14.1/lib/pry/input_lock.rb:75 + def with_ownership(&block); end + + class << self + # source://pry-0.14.1/lib/pry/input_lock.rb:19 + def for(input); end + + # Returns the value of attribute global_lock. + # + # source://pry-0.14.1/lib/pry/input_lock.rb:13 + def global_lock; end + + # Sets the attribute global_lock + # + # @param value the value to set the attribute global_lock to. + # + # source://pry-0.14.1/lib/pry/input_lock.rb:13 + def global_lock=(_arg0); end + + # Returns the value of attribute input_locks. + # + # source://pry-0.14.1/lib/pry/input_lock.rb:12 + def input_locks; end + + # Sets the attribute input_locks + # + # @param value the value to set the attribute input_locks to. + # + # source://pry-0.14.1/lib/pry/input_lock.rb:12 + def input_locks=(_arg0); end + end +end + +# source://pry-0.14.1/lib/pry/input_lock.rb:9 +class Pry::InputLock::Interrupt < ::Exception; end + +# source://pry-0.14.1/lib/pry/inspector.rb:4 +class Pry::Inspector; end + +# source://pry-0.14.1/lib/pry/inspector.rb:5 +Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash) + +# source://pry-0.14.1/lib/pry/pry_class.rb:7 +Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String) + +# source://pry-0.14.1/lib/pry/last_exception.rb:12 +class Pry::LastException < ::BasicObject + # @return [LastException] a new instance of LastException + # + # source://pry-0.14.1/lib/pry/last_exception.rb:15 + def initialize(exception); end + + # Returns the value of attribute bt_index. + # + # source://pry-0.14.1/lib/pry/last_exception.rb:13 + def bt_index; end + + # Sets the attribute bt_index + # + # @param value the value to set the attribute bt_index to. + # + # source://pry-0.14.1/lib/pry/last_exception.rb:13 + def bt_index=(_arg0); end + + # source://pry-0.14.1/lib/pry/last_exception.rb:52 + def bt_source_location_for(index); end + + # @return [String] returns the path to a file for the current backtrace. see {#bt_index}. + # + # source://pry-0.14.1/lib/pry/last_exception.rb:37 + def file; end + + # source://pry-0.14.1/lib/pry/last_exception.rb:57 + def inc_bt_index; end + + # @return [Fixnum] returns the line for the current backtrace. see {#bt_index}. + # + # source://pry-0.14.1/lib/pry/last_exception.rb:43 + def line; end + + # source://pry-0.14.1/lib/pry/last_exception.rb:21 + def method_missing(name, *args, &block); end + + # @return [Exception] returns the wrapped exception + # + # source://pry-0.14.1/lib/pry/last_exception.rb:48 + def wrapped_exception; end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/last_exception.rb:29 + def respond_to_missing?(name, include_all = T.unsafe(nil)); end +end + +# This class wraps the normal `Method` and `UnboundMethod` classes +# to provide extra functionality useful to Pry. +# +# source://pry-0.14.1/lib/pry/method.rb:20 +class Pry::Method + include ::Pry::Helpers::BaseHelpers + include ::Pry::Helpers::DocumentationHelpers + include ::Pry::CodeObject::Helpers + extend ::Pry::Helpers::BaseHelpers + extend ::Forwardable + extend ::Pry::Forwardable + + # A new instance of `Pry::Method` wrapping the given `::Method`, + # `UnboundMethod`, or `Proc`. + # + # @param method [::Method, UnboundMethod, Proc] + # @param known_info [Hash] Can be used to pre-cache expensive to compute stuff. + # @return [Pry::Method] + # + # source://pry-0.14.1/lib/pry/method.rb:263 + def initialize(method, known_info = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:483 + def ==(other); end + + # @return [Boolean] Is the method definitely an alias? + # + # source://pry-0.14.1/lib/pry/method.rb:478 + def alias?; end + + # @return [Array] All known aliases for the method. + # + # source://pry-0.14.1/lib/pry/method.rb:461 + def aliases; end + + # @return [Boolean] Whether the method is bound. + # + # source://pry-0.14.1/lib/pry/method.rb:446 + def bound_method?; end + + # source://pry-0.14.1/lib/pry/method.rb:515 + def comment; end + + # @return [String, nil] The documentation for the method, or `nil` if it's + # unavailable. + # + # source://pry-0.14.1/lib/pry/method.rb:329 + def doc; end + + # @return [Boolean] Was the method defined outside a source file? + # + # source://pry-0.14.1/lib/pry/method.rb:436 + def dynamically_defined?; end + + # @param klass [Class] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:491 + def is_a?(klass); end + + # @param klass [Class] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:491 + def kind_of?(klass); end + + # Delegate any unknown calls to the wrapped method. + # + # source://pry-0.14.1/lib/pry/method.rb:503 + def method_missing(method_name, *args, &block); end + + # Get the name of the method as a String, regardless of the underlying + # Method#name type. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/method.rb:272 + def name; end + + # Get the name of the method including the class on which it was defined. + # + # @example + # method(:puts).method_name + # => "Kernel.puts" + # @return [String] + # + # source://pry-0.14.1/lib/pry/method.rb:299 + def name_with_owner; end + + # @return [String, nil] The original name the method was defined under, + # before any aliasing, or `nil` if it can't be determined. + # + # source://pry-0.14.1/lib/pry/method.rb:429 + def original_name; end + + # source://RUBY_ROOT/forwardable.rb:226 + def owner(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def parameters(*args, &block); end + + # @return [Boolean] Was the method defined within the Pry REPL? + # + # source://pry-0.14.1/lib/pry/method.rb:456 + def pry_method?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def receiver(*args, &block); end + + # Update the live copy of the method's source. + # + # source://pry-0.14.1/lib/pry/method.rb:314 + def redefine(source); end + + # @param method_name [String, Symbol] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:498 + def respond_to?(method_name, include_all = T.unsafe(nil)); end + + # @return [String] A representation of the method's signature, including its + # name and parameters. Optional and "rest" parameters are marked with `*` + # and block parameters with `&`. Keyword arguments are shown with `:` + # If the parameter names are unavailable, they're given numbered names instead. + # Paraphrased from `awesome_print` gem. + # + # source://pry-0.14.1/lib/pry/method.rb:391 + def signature; end + + # @return [Boolean] Whether the method is a singleton method. + # + # source://pry-0.14.1/lib/pry/method.rb:451 + def singleton_method?; end + + # @return [String, nil] The source code of the method, or `nil` if it's unavailable. + # + # source://pry-0.14.1/lib/pry/method.rb:304 + def source; end + + # Can we get the source code for this method? + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:321 + def source?; end + + # @return [String, nil] The name of the file the method is defined in, or + # `nil` if the filename is unavailable. + # + # source://pry-0.14.1/lib/pry/method.rb:348 + def source_file; end + + # @return [Fixnum, nil] The line of code in `source_file` which begins + # the method's definition, or `nil` if that information is unavailable. + # + # source://pry-0.14.1/lib/pry/method.rb:361 + def source_line; end + + # @return [Range, nil] The range of lines in `source_file` which contain + # the method's definition, or `nil` if that information is unavailable. + # + # source://pry-0.14.1/lib/pry/method.rb:367 + def source_range; end + + # @return [Symbol] The source type of the method. The options are + # `:ruby` for Ruby methods or `:c` for methods written in C. + # + # source://pry-0.14.1/lib/pry/method.rb:342 + def source_type; end + + # @return [Pry::Method, nil] The wrapped method that is called when you + # use "super" in the body of this method. + # + # source://pry-0.14.1/lib/pry/method.rb:417 + def super(times = T.unsafe(nil)); end + + # @return [Boolean] Whether the method is unbound. + # + # source://pry-0.14.1/lib/pry/method.rb:441 + def unbound_method?; end + + # Is the method undefined? (aka `Disowned`) + # + # @return [Boolean] false + # + # source://pry-0.14.1/lib/pry/method.rb:290 + def undefined?; end + + # @return [Symbol] The visibility of the method. May be `:public`, + # `:protected`, or `:private`. + # + # source://pry-0.14.1/lib/pry/method.rb:373 + def visibility; end + + # Get underlying object wrapped by this Pry::Method instance + # + # @return [Method, UnboundMethod, Proc] + # + # source://pry-0.14.1/lib/pry/method.rb:284 + def wrapped; end + + # Get the owner of the method as a Pry::Module + # + # @return [Pry::Module] + # + # source://pry-0.14.1/lib/pry/method.rb:278 + def wrapped_owner; end + + private + + # source://pry-0.14.1/lib/pry/method.rb:577 + def c_source; end + + # @param first_ln [String] The first line of a method definition. + # @return [String, nil] + # + # source://pry-0.14.1/lib/pry/method.rb:563 + def method_name_from_first_line(first_ln); end + + # @raise [CommandError] when the method can't be found or `pry-doc` isn't installed. + # @return [YARD::CodeObjects::MethodObject] + # + # source://pry-0.14.1/lib/pry/method.rb:523 + def pry_doc_info; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:511 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/method.rb:582 + def ruby_source; end + + # @param ancestors [Class, Module] The ancestors to investigate + # @return [Method] The unwrapped super-method + # + # source://pry-0.14.1/lib/pry/method.rb:542 + def super_using_ancestors(ancestors, times = T.unsafe(nil)); end + + class << self + # Get all of the instance methods of a `Class` or `Module` + # + # @param klass [Class, Module] + # @param include_super [Boolean] Whether to include methods from ancestors. + # @return [Array[Pry::Method]] + # + # source://pry-0.14.1/lib/pry/method.rb:161 + def all_from_class(klass, include_super = T.unsafe(nil)); end + + # Get all of the methods on an `Object` + # + # @param obj [Object] + # @param include_super [Boolean] indicates whether or not to include methods from ancestors. + # @return [Array[Pry::Method]] + # + # source://pry-0.14.1/lib/pry/method.rb:184 + def all_from_obj(obj, include_super = T.unsafe(nil)); end + + # Given a `Binding`, try to extract the `::Method` it originated from and + # use it to instantiate a `Pry::Method`. Return `nil` if this isn't + # possible. + # + # @param binding [Binding] + # @return [Pry::Method, nil] + # + # source://pry-0.14.1/lib/pry/method.rb:77 + def from_binding(binding); end + + # Given a `Class` or `Module` and the name of a method, try to + # instantiate a `Pry::Method` containing the instance method of + # that name. Return `nil` if no such method exists. + # + # @param klass [Class, Module] + # @param name [String] + # @param target [Binding] The binding where the method is looked up. + # @return [Pry::Method, nil] + # + # source://pry-0.14.1/lib/pry/method.rb:136 + def from_class(klass, name, target = T.unsafe(nil)); end + + # Given a `Class` or `Module` and the name of a method, try to + # instantiate a `Pry::Method` containing the instance method of + # that name. Return `nil` if no such method exists. + # + # @param klass [Class, Module] + # @param name [String] + # @param target [Binding] The binding where the method is looked up. + # @return [Pry::Method, nil] + # + # source://pry-0.14.1/lib/pry/method.rb:136 + def from_module(klass, name, target = T.unsafe(nil)); end + + # Given an object and the name of a method, try to instantiate + # a `Pry::Method` containing the method of that name bound to + # that object. Return `nil` if no such method exists. + # + # @param obj [Object] + # @param name [String] + # @param target [Binding] The binding where the method is looked up. + # @return [Pry::Method, nil] + # + # source://pry-0.14.1/lib/pry/method.rb:151 + def from_obj(obj, name, target = T.unsafe(nil)); end + + # Given a string representing a method name and optionally a binding to + # search in, find and return the requested method wrapped in a + # `Pry::Method` instance. + # + # @option options + # @option options + # @param name [String] The name of the method to retrieve. + # @param target [Binding] The context in which to search for the method. + # @param options [Hash] + # @return [Pry::Method, nil] A `Pry::Method` instance containing the + # requested method, or `nil` if name is `nil` or no method could be + # located matching the parameters. + # + # source://pry-0.14.1/lib/pry/method.rb:43 + def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:227 + def instance_method_definition?(name, definition_line); end + + # Get every `Class` and `Module`, in order, that will be checked when looking + # for methods on instances of the given `Class` or `Module`. + # This does not treat singleton classes of classes specially. + # + # @param klass [Class, Module] + # @return [Array[Class, Module]] + # + # source://pry-0.14.1/lib/pry/method.rb:210 + def instance_resolution_order(klass); end + + # In order to support 2.0 Refinements we need to look up methods + # inside the relevant Binding. + # + # @param obj [Object] The owner/receiver of the method. + # @param method_name [Symbol] The name of the method. + # @param method_type [Symbol] The type of method: :method or :instance_method + # @param target [Binding] The binding where the method is looked up. + # @return [Method, UnboundMethod] The 'refined' method object. + # + # source://pry-0.14.1/lib/pry/method.rb:114 + def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:215 + def method_definition?(name, definition_line); end + + # Get every `Class` and `Module`, in order, that will be checked when looking + # for an instance method to call on this object. + # + # @param obj [Object] + # @return [Array[Class, Module]] + # + # source://pry-0.14.1/lib/pry/method.rb:192 + def resolution_order(obj); end + + # source://pry-0.14.1/lib/pry/method.rb:247 + def singleton_class_of(obj); end + + # Get the singleton classes of superclasses that could define methods on + # the given class object, and any modules they include. + # If a module is included at multiple points in the ancestry, only + # the lowest copy will be returned. + # + # source://pry-0.14.1/lib/pry/method.rb:238 + def singleton_class_resolution_order(klass); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method.rb:220 + def singleton_method_definition?(name, definition_line); end + end +end + +# A Disowned Method is one that's been removed from the class on which it was defined. +# +# e.g. +# class C +# def foo +# C.send(:undefine_method, :foo) +# Pry::Method.from_binding(binding) +# end +# end +# +# In this case we assume that the "owner" is the singleton class of the receiver. +# +# This occurs mainly in Sinatra applications. +# +# source://pry-0.14.1/lib/pry/method/disowned.rb:18 +class Pry::Method::Disowned < ::Pry::Method + # Create a new Disowned method. + # + # @param receiver [Object] + # @param method_name [String] + # @return [Disowned] a new instance of Disowned + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:25 + def initialize(receiver, method_name); end + + # Raise a more useful error message instead of trying to forward to nil. + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:52 + def method_missing(method_name, *args, &block); end + + # Returns the value of attribute name. + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:19 + def name; end + + # Get the hypothesized owner of the method. + # + # @return [Object] + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:46 + def owner; end + + # Returns the value of attribute receiver. + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:19 + def receiver; end + + # Can we get the source for this method? + # + # @return [Boolean] false + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:39 + def source?; end + + # Is the method undefined? (aka `Disowned`) + # + # @return [Boolean] true + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:33 + def undefined?; end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/disowned.rb:62 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end +end + +# source://pry-0.14.1/lib/pry/method/patcher.rb:5 +class Pry::Method::Patcher + # @return [Patcher] a new instance of Patcher + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:12 + def initialize(method); end + + # Returns the value of attribute method. + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:6 + def method; end + + # Sets the attribute method + # + # @param value the value to set the attribute method to. + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:6 + def method=(_arg0); end + + # perform the patch + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:21 + def patch_in_ram(source); end + + private + + # source://pry-0.14.1/lib/pry/method/patcher.rb:38 + def cache_key; end + + # Update the definition line so that it can be eval'd directly on the Method's + # owner instead of from the original context. + # + # In particular this takes `def self.foo` and turns it into `def foo` so that we + # don't end up creating the method on the singleton class of the singleton class + # by accident. + # + # This is necessarily done by String manipulation because we can't find out what + # syntax is needed for the argument list by ruby-level introspection. + # + # @param line [String] The original definition line. e.g. def self.foo(bar, baz=1) + # @return [String] The new definition line. e.g. def foo(bar, baz=1) + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:78 + def definition_for_owner(line); end + + # source://pry-0.14.1/lib/pry/method/patcher.rb:33 + def redefine(source); end + + # Run some code ensuring that at the end target#meth_name will not have changed. + # + # When we're redefining aliased methods we will overwrite the method at the + # unaliased name (so that super continues to work). By wrapping that code in a + # transation we make that not happen, which means that alias_method_chains, etc. + # continue to work. + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:49 + def with_method_transaction; end + + # Apply wrap_for_owner and wrap_for_nesting successively to `source` + # + # @param source [String] + # @return [String] The wrapped source. + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:91 + def wrap(source); end + + # Update the new source code to have the correct Module.nesting. + # + # This method uses syntactic analysis of the original source file to determine + # the new nesting, so that we can tell the difference between: + # + # class A; def self.b; end; end + # class << A; def b; end; end + # + # The resulting code should be evaluated in the TOPLEVEL_BINDING. + # + # @param source [String] The source to wrap. + # @return [String] + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:122 + def wrap_for_nesting(source); end + + # Update the source code so that when it has the right owner when eval'd. + # + # This (combined with definition_for_owner) is backup for the case that + # wrap_for_nesting fails, to ensure that the method will stil be defined in + # the correct place. + # + # @param source [String] The source to wrap + # @return [String] + # + # source://pry-0.14.1/lib/pry/method/patcher.rb:103 + def wrap_for_owner(source); end + + class << self + # source://pry-0.14.1/lib/pry/method/patcher.rb:16 + def code_for(filename); end + end +end + +# This class is responsible for locating the *real* `Pry::Method` +# object captured by a binding. +# +# Given a `Binding` from inside a method and a 'seed' Pry::Method object, +# there are primarily two situations where the seed method doesn't match +# the Binding: +# 1. The Pry::Method is from a subclass +# 2. The Pry::Method represents a method of the same name while the original +# was renamed to something else. For 1. we search vertically up the +# inheritance chain, and for 2. we search laterally along the object's +# method table. +# +# When we locate the method that matches the Binding we wrap it in +# Pry::Method and return it, or return nil if we fail. +# +# source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:19 +class Pry::Method::WeirdMethodLocator + # @param method [Pry::Method] The seed method. + # @param target [Binding] The Binding that captures the method + # we want to locate. + # @return [WeirdMethodLocator] a new instance of WeirdMethodLocator + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:55 + def initialize(method, target); end + + # @return [Pry::Method, nil] The Pry::Method that matches the + # given binding. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:62 + def find_method; end + + # @return [Boolean] Whether the Pry::Method is unrecoverable + # This usually happens when the method captured by the Binding + # has been subsequently deleted. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:69 + def lost_method?; end + + # Returns the value of attribute method. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:49 + def method; end + + # Sets the attribute method + # + # @param value the value to set the attribute method to. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:49 + def method=(_arg0); end + + # Returns the value of attribute target. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:50 + def target; end + + # Sets the attribute target + # + # @param value the value to set the attribute target to. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:50 + def target=(_arg0); end + + private + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:215 + def all_methods_for(obj); end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:167 + def expanded_source_location(source_location); end + + # it's possible in some cases that the method we find by this approach is + # a sub-method of the one we're currently in, consider: + # + # class A; def b; binding.pry; end; end + # class B < A; def b; super; end; end + # + # Given that we can normally find the source_range of methods, and that we + # know which __FILE__ and __LINE__ the binding is at, we can hope to + # disambiguate these cases. + # + # This obviously won't work if the source is unavaiable for some reason, + # or if both methods have the same __FILE__ and __LINE__. + # + # @return [Pry::Method, nil] The Pry::Method representing the + # superclass method. + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:131 + def find_method_in_superclass; end + + # This is the case where the name of a method has changed + # (via alias_method) so we locate the Method object for the + # renamed method. + # + # @return [Pry::Method, nil] The Pry::Method representing the + # renamed method + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:156 + def find_renamed_method; end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:197 + def index_to_line_number(index); end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:206 + def lines_for_file(file); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:80 + def normal_method?(method); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:106 + def pry_file?; end + + # Use static analysis to locate the start of the method definition. + # We have the `__FILE__` and `__LINE__` from the binding and the + # original name of the method so we search up until we find a + # def/define_method, etc defining a method of the appropriate name. + # + # @return [Array] The `source_location` of the + # renamed method + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:184 + def renamed_method_source_location; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:75 + def skip_superclass_search?; end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:88 + def target_file; end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:98 + def target_line; end + + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:84 + def target_self; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:202 + def valid_file?(file); end + + class << self + # Whether the given method object matches the associated binding. + # If the method object does not match the binding, then it's + # most likely not the method captured by the binding, and we + # must commence a search. + # + # @param method [Pry::Method] + # @param binding [Binding] + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:29 + def normal_method?(method, binding); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/method/weird_method_locator.rb:44 + def weird_method?(method, binding); end + end +end + +# source://pry-0.14.1/lib/pry/exceptions.rb:69 +class Pry::MethodNotFound < ::Pry::CommandError; end + +# source://pry-0.14.1/lib/pry/command_set.rb:4 +class Pry::NoCommandError < ::StandardError + # @return [NoCommandError] a new instance of NoCommandError + # + # source://pry-0.14.1/lib/pry/command_set.rb:5 + def initialize(match, owner); end +end + +# `ObjectPath` implements the resolution of "object paths", which are strings +# that are similar to filesystem paths but meant for traversing Ruby objects. +# Examples of valid object paths include: +# +# x +# @foo/@bar +# "string"/upcase +# Pry/Method +# +# Object paths are mostly relevant in the context of the `cd` command. +# +# @see https://github.com/pry/pry/wiki/State-navigation +# +# source://pry-0.14.1/lib/pry/object_path.rb:17 +class Pry::ObjectPath + # @param path_string [String] The object path expressed as a string. + # @param current_stack [Array] The current state of the binding + # stack. + # @return [ObjectPath] a new instance of ObjectPath + # + # source://pry-0.14.1/lib/pry/object_path.rb:23 + def initialize(path_string, current_stack); end + + # @return [Array] a new stack resulting from applying the given + # path to the current stack. + # + # source://pry-0.14.1/lib/pry/object_path.rb:30 + def resolve; end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/object_path.rb:74 + def complete?(segment); end + + # source://pry-0.14.1/lib/pry/object_path.rb:78 + def handle_failure(context, err); end +end + +# source://pry-0.14.1/lib/pry/object_path.rb:18 +Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array) + +# indicates obsolete API +# +# source://pry-0.14.1/lib/pry/exceptions.rb:72 +class Pry::ObsoleteError < ::StandardError; end + +# source://pry-0.14.1/lib/pry/output.rb:4 +class Pry::Output + # @return [Output] a new instance of Output + # + # source://pry-0.14.1/lib/pry/output.rb:10 + def initialize(pry_instance); end + + # source://pry-0.14.1/lib/pry/output.rb:28 + def <<(*objs); end + + # source://pry-0.14.1/lib/pry/output.rb:53 + def decolorize_maybe(str); end + + # Return a screen height or the default if that fails. + # + # source://pry-0.14.1/lib/pry/output.rb:74 + def height; end + + # source://pry-0.14.1/lib/pry/output.rb:41 + def method_missing(method_name, *args, &block); end + + # source://pry-0.14.1/lib/pry/output.rb:28 + def print(*objs); end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/output.rb:8 + def pry_instance; end + + # source://pry-0.14.1/lib/pry/output.rb:15 + def puts(*objs); end + + # @return [Array] a pair of [rows, columns] which gives the size of + # the window. If the window size cannot be determined, the default value. + # + # source://pry-0.14.1/lib/pry/output.rb:61 + def size; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/output.rb:37 + def tty?; end + + # Return a screen width or the default if that fails. + # + # source://pry-0.14.1/lib/pry/output.rb:69 + def width; end + + # source://pry-0.14.1/lib/pry/output.rb:28 + def write(*objs); end + + private + + # source://pry-0.14.1/lib/pry/output.rb:80 + def actual_screen_size; end + + # source://pry-0.14.1/lib/pry/output.rb:125 + def ansicon_env_size; end + + # source://pry-0.14.1/lib/pry/output.rb:109 + def env_size; end + + # source://pry-0.14.1/lib/pry/output.rb:92 + def io_console_size; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/output.rb:132 + def nonzero_column?(size); end + + # source://pry-0.14.1/lib/pry/output.rb:114 + def readline_size; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/output.rb:49 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end +end + +# @return [Array] default terminal screen size [rows, cols] +# +# source://pry-0.14.1/lib/pry/output.rb:6 +Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array) + +# source://pry-0.14.1/lib/pry/pager.rb:7 +class Pry::Pager + # @return [Pager] a new instance of Pager + # + # source://pry-0.14.1/lib/pry/pager.rb:13 + def initialize(pry_instance); end + + # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`). + # All pagers accept output with `#puts`, `#print`, `#write`, and `#<<`. + # + # source://pry-0.14.1/lib/pry/pager.rb:33 + def open; end + + # Send the given text through the best available pager (if + # `Pry.config.pager` is enabled). If you want to send text through in + # chunks as you generate it, use `open` to get a writable object + # instead. + # + # @param text [String] Text to run through a pager. + # + # source://pry-0.14.1/lib/pry/pager.rb:25 + def page(text); end + + # Returns the value of attribute pry_instance. + # + # source://pry-0.14.1/lib/pry/pager.rb:11 + def pry_instance; end + + private + + # Return an instance of the "best" available pager class -- + # `SystemPager` if possible, `SimplePager` if `SystemPager` isn't + # available, and `NullPager` if the user has disabled paging. All + # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`. You + # must call `#close` when you're done writing output to a pager, and + # you must rescue `Pry::Pager::StopPaging`. These requirements can be + # avoided by using `.open` instead. + # + # source://pry-0.14.1/lib/pry/pager.rb:56 + def best_available; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pager.rb:43 + def enabled?; end + + # Returns the value of attribute output. + # + # source://pry-0.14.1/lib/pry/pager.rb:47 + def output; end +end + +# `NullPager` is a "pager" that actually just prints all output as it +# comes in. Used when `Pry.config.pager` is false. +# +# source://pry-0.14.1/lib/pry/pager.rb:68 +class Pry::Pager::NullPager + # @return [NullPager] a new instance of NullPager + # + # source://pry-0.14.1/lib/pry/pager.rb:69 + def initialize(out); end + + # source://pry-0.14.1/lib/pry/pager.rb:77 + def <<(str); end + + # source://pry-0.14.1/lib/pry/pager.rb:86 + def close; end + + # source://pry-0.14.1/lib/pry/pager.rb:77 + def print(str); end + + # source://pry-0.14.1/lib/pry/pager.rb:73 + def puts(str); end + + # source://pry-0.14.1/lib/pry/pager.rb:82 + def write(str); end + + private + + # source://pry-0.14.1/lib/pry/pager.rb:90 + def height; end + + # source://pry-0.14.1/lib/pry/pager.rb:94 + def width; end +end + +# `PageTracker` tracks output to determine whether it's likely to take +# up a whole page. This doesn't need to be super precise, but we can +# use it for `SimplePager` and to avoid invoking the system pager +# unnecessarily. +# +# One simplifying assumption is that we don't need `#page?` to return +# `true` on the basis of an incomplete line. Long lines should be +# counted as multiple lines, but we don't have to transition from +# `false` to `true` until we see a newline. +# +# source://pry-0.14.1/lib/pry/pager.rb:213 +class Pry::Pager::PageTracker + # @return [PageTracker] a new instance of PageTracker + # + # source://pry-0.14.1/lib/pry/pager.rb:214 + def initialize(rows, cols); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pager.rb:231 + def page?; end + + # source://pry-0.14.1/lib/pry/pager.rb:220 + def record(str); end + + # source://pry-0.14.1/lib/pry/pager.rb:235 + def reset; end + + private + + # Approximation of the printable length of a given line, without the + # newline and without ANSI color codes. + # + # source://pry-0.14.1/lib/pry/pager.rb:244 + def line_length(line); end +end + +# `SimplePager` is a straightforward pure-Ruby pager. We use it on +# JRuby and when we can't find a usable external pager. +# +# source://pry-0.14.1/lib/pry/pager.rb:101 +class Pry::Pager::SimplePager < ::Pry::Pager::NullPager + # @return [SimplePager] a new instance of SimplePager + # + # source://pry-0.14.1/lib/pry/pager.rb:102 + def initialize(*_arg0); end + + # source://pry-0.14.1/lib/pry/pager.rb:107 + def write(str); end +end + +# source://pry-0.14.1/lib/pry/pager.rb:8 +class Pry::Pager::StopPaging < ::StandardError; end + +# `SystemPager` buffers output until we're pretty sure it's at least a +# page long, then invokes an external pager and starts streaming output +# to it. If `#close` is called before then, it just prints out the +# buffered content. +# +# source://pry-0.14.1/lib/pry/pager.rb:129 +class Pry::Pager::SystemPager < ::Pry::Pager::NullPager + # @return [SystemPager] a new instance of SystemPager + # + # source://pry-0.14.1/lib/pry/pager.rb:161 + def initialize(*_arg0); end + + # source://pry-0.14.1/lib/pry/pager.rb:181 + def close; end + + # source://pry-0.14.1/lib/pry/pager.rb:168 + def write(str); end + + private + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pager.rb:195 + def invoked_pager?; end + + # source://pry-0.14.1/lib/pry/pager.rb:199 + def pager; end + + # source://pry-0.14.1/lib/pry/pager.rb:191 + def write_to_pager(text); end + + class << self + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/pager.rb:142 + def available?; end + + # source://pry-0.14.1/lib/pry/pager.rb:130 + def default_pager; end + end +end + +# Prompt represents the Pry prompt, which can be used with Readline-like +# libraries. It defines a few default prompts (default prompt, simple prompt, +# etc) and also provides an API for adding and implementing custom prompts. +# +# @api public +# @example Registering a new Pry prompt +# Pry::Prompt.add( +# :ipython, +# 'IPython-like prompt', [':', '...:'] +# ) do |_context, _nesting, pry_instance, sep| +# sep == ':' ? "In [#{pry_instance.input_ring.count}]: " : ' ...: ' +# end +# +# # Produces: +# # In [3]: def foo +# # ...: puts 'foo' +# # ...: end +# # => :foo +# # In [4]: +# @example Manually instantiating the Prompt class +# prompt_procs = [ +# proc { '#{rand(1)}>" }, +# proc { "#{('a'..'z').to_a.sample}*" } +# ] +# prompt = Pry::Prompt.new( +# :random, +# 'Random number or letter prompt.', +# prompt_procs +# ) +# prompt.wait_proc.call(...) #=> +# prompt.incomplete_proc.call(...) +# @since v0.11.0 +# +# source://pry-0.14.1/lib/pry/prompt.rb:38 +class Pry::Prompt + # @api public + # @param name [String] + # @param description [String] + # @param prompt_procs [Array] + # @return [Prompt] a new instance of Prompt + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:117 + def initialize(name, description, prompt_procs); end + + # @api public + # @deprecated Use a `Pry::Prompt` instance directly + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:135 + def [](key); end + + # @api public + # @return [String] + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:108 + def description; end + + # @api public + # @return [Proc] the proc which builds the prompt when in the middle of an + # expression such as open method, etc. (`*`) + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:130 + def incomplete_proc; end + + # @api public + # @return [String] + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:105 + def name; end + + # @api public + # @return [Array] the array of procs that hold + # `[wait_proc, incomplete_proc]` + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:112 + def prompt_procs; end + + # @api public + # @return [Proc] the proc which builds the wait prompt (`>`) + # @since v0.11.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:124 + def wait_proc; end + + class << self + # Retrieves a prompt. + # + # @api public + # @example + # Prompt[:my_prompt] + # @param name [Symbol] The name of the prompt you want to access + # @return [Hash{Symbol=>Object}] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:52 + def [](name); end + + # Adds a new prompt to the prompt hash. + # + # @api public + # @param name [Symbol] + # @param description [String] + # @param separators [Array] The separators to differentiate + # between prompt modes (default mode and class/method definition mode). + # The Array *must* have a size of 2. + # @raise [ArgumentError] if the size of `separators` is not 2 + # @raise [ArgumentError] if `prompt_name` is already occupied + # @return [nil] + # @since v0.12.0 + # @yield [context, nesting, pry_instance, sep] + # @yieldparam context [Object] the context where Pry is currently in + # @yieldparam nesting [Integer] whether the context is nested + # @yieldparam pry_instance [Pry] the Pry instance + # @yieldparam separator [String] separator string + # + # source://pry-0.14.1/lib/pry/prompt.rb:79 + def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end + + # @api public + # @note Use this for read-only operations + # @return [Hash{Symbol=>Hash}] the duplicate of the internal prompts hash + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/prompt.rb:59 + def all; end + end +end + +# source://pry-0.14.1/lib/pry/repl.rb:4 +class Pry::REPL + extend ::Forwardable + extend ::Pry::Forwardable + + # Create an instance of {REPL} wrapping the given {Pry}. + # + # @option options + # @param pry [Pry] The instance of {Pry} that this {REPL} will control. + # @param options [Hash] Options for this {REPL} instance. + # @return [REPL] a new instance of REPL + # + # source://pry-0.14.1/lib/pry/repl.rb:22 + def initialize(pry, options = T.unsafe(nil)); end + + # source://RUBY_ROOT/forwardable.rb:226 + def input(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def output(*args, &block); end + + # @return [Pry] The instance of {Pry} that the user is controlling. + # + # source://pry-0.14.1/lib/pry/repl.rb:9 + def pry; end + + # @return [Pry] The instance of {Pry} that the user is controlling. + # + # source://pry-0.14.1/lib/pry/repl.rb:9 + def pry=(_arg0); end + + # Start the read-eval-print loop. + # + # @raise [Exception] If the session throws `:raise_up`, raise the exception + # thrown with it. + # @return [Object?] If the session throws `:breakout`, return the value + # thrown with it. + # + # source://pry-0.14.1/lib/pry/repl.rb:36 + def start; end + + private + + # Calculates correct overhang for current line. Supports vi Readline + # mode and its indicators such as "(ins)" or "(cmd)". + # + # @note This doesn't calculate overhang for Readline's emacs mode with an + # indicator because emacs is the default mode and it doesn't use + # indicators in 99% of cases. + # @return [Integer] + # + # source://pry-0.14.1/lib/pry/repl.rb:238 + def calculate_overhang(current_prompt, original_val, indented_val); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:206 + def coolline_available?; end + + # Clean up after the repl session. + # + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:84 + def epilogue; end + + # Manage switching of input objects on encountering `EOFError`s. + # + # @return [Object] Whatever the given block returns. + # @return [:no_more_input] Indicates that no more input can be read. + # + # source://pry-0.14.1/lib/pry/repl.rb:127 + def handle_read_errors; end + + # source://pry-0.14.1/lib/pry/repl.rb:196 + def input_readline(*args); end + + # If `$stdout` is not a tty, it's probably a pipe. + # + # @example + # # `piping?` returns `false` + # % pry + # [1] pry(main) + # + # # `piping?` returns `true` + # % pry | tee log + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:218 + def piping?; end + + # Set up the repl session. + # + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:47 + def prologue; end + + # Read a line of input from the user. + # + # @return [String] The line entered by the user. + # @return [nil] On ``. + # @return [:control_c] On ``. + # @return [:no_more_input] On EOF. + # + # source://pry-0.14.1/lib/pry/repl.rb:93 + def read; end + + # Returns the next line of input to be sent to the {Pry} instance. + # + # @param current_prompt [String] The prompt to use for input. + # @return [String?] The next line of input, or `nil` on . + # + # source://pry-0.14.1/lib/pry/repl.rb:170 + def read_line(current_prompt); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/repl.rb:202 + def readline_available?; end + + # The actual read-eval-print loop. + # + # The {REPL} instance is responsible for reading and looping, whereas the + # {Pry} instance is responsible for evaluating user input and printing + # return values and command output. + # + # @raise [Exception] If the session throws `:raise_up`, raise the exception + # thrown with it. + # @return [Object?] If the session throws `:breakout`, return the value + # thrown with it. + # + # source://pry-0.14.1/lib/pry/repl.rb:66 + def repl; end + + # @return [void] + # + # source://pry-0.14.1/lib/pry/repl.rb:225 + def set_readline_output; end + + class << self + # Instantiate a new {Pry} instance with the given options, then start a + # {REPL} instance wrapping it. + # + # @option options + # @param options [Hash] a customizable set of options + # + # source://pry-byebug-3.10.1/lib/pry-byebug/pry_ext.rb:8 + def start(options = T.unsafe(nil)); end + + # source://pry-byebug-3.10.1/lib/pry-byebug/pry_ext.rb:8 + def start_with_pry_byebug(options = T.unsafe(nil)); end + + # source://pry-0.14.1/lib/pry/repl.rb:14 + def start_without_pry_byebug(options); end + end +end + +# A class to manage the loading of files through the REPL loop. +# This is an interesting trick as it processes your file as if it +# was user input in an interactive session. As a result, all Pry +# commands are available, and they are executed non-interactively. Furthermore +# the session becomes interactive when the repl loop processes a +# 'make-interactive' command in the file. The session also becomes +# interactive when an exception is encountered, enabling you to fix +# the error before returning to non-interactive processing with the +# 'make-non-interactive' command. +# +# source://pry-0.14.1/lib/pry/repl_file_loader.rb:14 +class Pry::REPLFileLoader + # @return [REPLFileLoader] a new instance of REPLFileLoader + # + # source://pry-0.14.1/lib/pry/repl_file_loader.rb:15 + def initialize(file_name); end + + # Define a few extra commands useful for flipping back & forth + # between interactive/non-interactive modes + # + # source://pry-0.14.1/lib/pry/repl_file_loader.rb:59 + def define_additional_commands; end + + # Switch to interactive mode, i.e take input from the user + # and use the regular print and exception handlers. + # + # @param pry_instance [Pry] the Pry instance to make interactive. + # + # source://pry-0.14.1/lib/pry/repl_file_loader.rb:26 + def interactive_mode(pry_instance); end + + # Actually load the file through the REPL by setting file content + # as the REPL input stream. + # + # source://pry-0.14.1/lib/pry/repl_file_loader.rb:75 + def load; end + + # Switch to non-interactive mode. Essentially + # this means there is no result output + # and that the session becomes interactive when an exception is encountered. + # + # @param pry_instance [Pry] the Pry instance to make non-interactive. + # + # source://pry-0.14.1/lib/pry/repl_file_loader.rb:37 + def non_interactive_mode(pry_instance, content); end +end + +# As a REPL, we often want to catch any unexpected exceptions that may have +# been raised; however we don't want to go overboard and prevent the user +# from exiting Pry when they want to. +# +# source://pry-0.14.1/lib/pry/exceptions.rb:7 +module Pry::RescuableException + class << self + # source://pry-0.14.1/lib/pry/exceptions.rb:8 + def ===(exception); end + end +end + +# Wraps the return result of process_commands, indicates if the +# result IS a command and what kind of command (e.g void) +# +# source://pry-0.14.1/lib/pry/command_set.rb:397 +class Pry::Result + # @return [Result] a new instance of Result + # + # source://pry-0.14.1/lib/pry/command_set.rb:400 + def initialize(is_command, retval = T.unsafe(nil)); end + + # Is the result a command? + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/command_set.rb:407 + def command?; end + + # Returns the value of attribute retval. + # + # source://pry-0.14.1/lib/pry/command_set.rb:398 + def retval; end + + # Is the result a command and if it is, is it a void command? + # (one that does not return a value) + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/command_set.rb:414 + def void_command?; end +end + +# A ring is a thread-safe fixed-capacity array to which you can only add +# elements. Older entries are overwritten as you add new elements, so that the +# ring can never contain more than `max_size` elemens. +# +# @api public +# @example +# ring = Pry::Ring.new(3) +# ring << 1 << 2 << 3 +# ring.to_a #=> [1, 2, 3] +# ring << 4 +# ring.to_a #=> [2, 3, 4] +# +# ring[0] #=> 2 +# ring[-1] #=> 4 +# ring.clear +# ring[0] #=> nil +# @since v0.12.0 +# +# source://pry-0.14.1/lib/pry/ring.rb:22 +class Pry::Ring + # @api public + # @param max_size [Integer] Maximum buffer size. The buffer will start + # overwriting elements once its reaches its maximum capacity + # @return [Ring] a new instance of Ring + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:33 + def initialize(max_size); end + + # Push `value` to the current index. + # + # @api public + # @param value [Object] + # @return [self] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:43 + def <<(value); end + + # Read the value stored at `index`. + # + # @api public + # @param index [Integer, Range] The element (if Integer) or elements + # (if Range) associated with `index` + # @return [Object, Array, nil] element(s) at `index`, `nil` if none + # exist + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:57 + def [](index); end + + # Clear the buffer and reset count. + # + # @api public + # @return [void] + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:75 + def clear; end + + # @api public + # @return [Integer] how many objects were added during the lifetime of the + # ring + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:28 + def count; end + + # @api public + # @return [Integer] maximum buffer size + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:24 + def max_size; end + + # @api public + # @return [Integer] how many objects were added during the lifetime of the + # ring + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:28 + def size; end + + # @api public + # @return [Array] the buffer as unwinded array + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:67 + def to_a; end + + private + + # @api public + # @since v0.12.0 + # + # source://pry-0.14.1/lib/pry/ring.rb:84 + def transpose_buffer_tail; end +end + +# source://pry-0.14.1/lib/pry/slop.rb:5 +class Pry::Slop + include ::Enumerable + + # Create a new instance of Slop and optionally build options via a block. + # + # config - A Hash of configuration options. + # block - An optional block used to specify options. + # + # @return [Slop] a new instance of Slop + # + # source://pry-0.14.1/lib/pry/slop.rb:127 + def initialize(config = T.unsafe(nil), &block); end + + # Fetch an options argument value. + # + # key - The Symbol or String option short or long flag. + # + # Returns the Object value for this option, or nil. + # + # source://pry-0.14.1/lib/pry/slop.rb:278 + def [](key); end + + # Add a callback. + # + # label - The Symbol identifier to attach this callback. + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop.rb:398 + def add_callback(label, &block); end + + # Get or set the banner. + # + # banner - The String to set the banner. + # + # Returns the banner String. + # + # source://pry-0.14.1/lib/pry/slop.rb:168 + def banner(banner = T.unsafe(nil)); end + + # Set the banner. + # + # banner - The String to set the banner. + # + # source://pry-0.14.1/lib/pry/slop.rb:159 + def banner=(banner); end + + # Add a new command. + # + # command - The Symbol or String used to identify this command. + # options - A Hash of configuration options (see Slop::new) + # + # Returns a new instance of Slop mapped to this command. + # + # source://pry-0.14.1/lib/pry/slop.rb:196 + def command(command, options = T.unsafe(nil), &block); end + + # The Hash of configuration options for this Slop instance. + # + # source://pry-0.14.1/lib/pry/slop.rb:118 + def config; end + + # Get or set the description (used for commands). + # + # desc - The String to set the description. + # + # Returns the description String. + # + # source://pry-0.14.1/lib/pry/slop.rb:185 + def description(desc = T.unsafe(nil)); end + + # Set the description (used for commands). + # + # desc - The String to set the description. + # + # source://pry-0.14.1/lib/pry/slop.rb:176 + def description=(desc); end + + # Enumerable interface. Yields each Slop::Option. + # + # source://pry-0.14.1/lib/pry/slop.rb:297 + def each(&block); end + + # Fetch a Slop object associated with this command. + # + # command - The String or Symbol name of the command. + # + # Examples: + # + # opts.command :foo do + # on :v, :verbose, 'Enable verbose mode' + # end + # + # # ruby run.rb foo -v + # opts.fetch_command(:foo).verbose? #=> true + # + # source://pry-0.14.1/lib/pry/slop.rb:389 + def fetch_command(command); end + + # Fetch a Slop::Option object. + # + # key - The Symbol or String option key. + # + # Examples: + # + # opts.on(:foo, 'Something fooey', :argument => :optional) + # opt = opts.fetch_option(:foo) + # opt.class #=> Slop::Option + # opt.accepts_optional_argument? #=> true + # + # Returns an Option or nil if none were found. + # + # source://pry-0.14.1/lib/pry/slop.rb:373 + def fetch_option(key); end + + # Fetch an options argument value. + # + # key - The Symbol or String option short or long flag. + # + # Returns the Object value for this option, or nil. + # + # source://pry-0.14.1/lib/pry/slop.rb:278 + def get(key); end + + # Print a handy Slop help string. + # + # Returns the banner followed by available option help strings. + # + # source://pry-0.14.1/lib/pry/slop.rb:416 + def help; end + + # Fetch a list of options which were missing from the parsed list. + # + # Examples: + # + # opts = Slop.new do + # on :n, :name= + # on :p, :password= + # end + # + # opts.parse %w[ --name Lee ] + # opts.missing #=> ['password'] + # + # Returns an Array of Strings representing missing options. + # + # source://pry-0.14.1/lib/pry/slop.rb:357 + def missing; end + + # Add an Option. + # + # objects - An Array with an optional Hash as the last element. + # + # Examples: + # + # on '-u', '--username=', 'Your username' + # on :v, :verbose, 'Enable verbose mode' + # + # Returns the created instance of Slop::Option. + # + # source://pry-0.14.1/lib/pry/slop.rb:265 + def on(*objects, &block); end + + # Add an Option. + # + # objects - An Array with an optional Hash as the last element. + # + # Examples: + # + # on '-u', '--username=', 'Your username' + # on :v, :verbose, 'Enable verbose mode' + # + # Returns the created instance of Slop::Option. + # + # source://pry-0.14.1/lib/pry/slop.rb:265 + def opt(*objects, &block); end + + # Add an Option. + # + # objects - An Array with an optional Hash as the last element. + # + # Examples: + # + # on '-u', '--username=', 'Your username' + # on :v, :verbose, 'Enable verbose mode' + # + # Returns the created instance of Slop::Option. + # + # source://pry-0.14.1/lib/pry/slop.rb:265 + def option(*objects, &block); end + + # The Array of Slop::Option objects tied to this Slop instance. + # + # source://pry-0.14.1/lib/pry/slop.rb:121 + def options; end + + # Parse a list of items, executing and gathering options along the way. + # + # items - The Array of items to extract options from (default: ARGV). + # block - An optional block which when used will yield non options. + # + # Returns an Array of original items. + # + # source://pry-0.14.1/lib/pry/slop.rb:206 + def parse(items = T.unsafe(nil), &block); end + + # Parse a list of items, executing and gathering options along the way. + # unlike parse() this method will remove any options and option arguments + # from the original Array. + # + # items - The Array of items to extract options from (default: ARGV). + # block - An optional block which when used will yield non options. + # + # Returns an Array of original items with options removed. + # + # source://pry-0.14.1/lib/pry/slop.rb:219 + def parse!(items = T.unsafe(nil), &block); end + + # Check for an options presence. + # + # Examples: + # + # opts.parse %w( --foo ) + # opts.present?(:foo) #=> true + # opts.present?(:bar) #=> false + # + # Returns true if all of the keys are present in the parsed arguments. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop.rb:333 + def present?(*keys); end + + # Specify code to be executed when these options are parsed. + # + # callable - An object responding to a call method. + # + # yields - The instance of Slop parsing these options + # An Array of unparsed arguments + # + # Example: + # + # Slop.parse do + # on :v, :verbose + # + # run do |opts, args| + # puts "Arguments: #{args.inspect}" if opts.verbose? + # end + # end + # + # @raise [ArgumentError] + # + # source://pry-0.14.1/lib/pry/slop.rb:317 + def run(callable = T.unsafe(nil), &block); end + + # Add string separators between options. + # + # text - The String text to print. + # + # source://pry-0.14.1/lib/pry/slop.rb:405 + def separator(text); end + + # Is strict mode enabled? + # + # Returns true if strict mode is enabled, false otherwise. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop.rb:152 + def strict?; end + + # Returns a new Hash with option flags as keys and option values as values. + # + # include_commands - If true, merge options from all sub-commands. + # + # source://pry-0.14.1/lib/pry/slop.rb:287 + def to_h(include_commands = T.unsafe(nil)); end + + # Returns a new Hash with option flags as keys and option values as values. + # + # include_commands - If true, merge options from all sub-commands. + # + # source://pry-0.14.1/lib/pry/slop.rb:287 + def to_hash(include_commands = T.unsafe(nil)); end + + # Print a handy Slop help string. + # + # Returns the banner followed by available option help strings. + # + # source://pry-0.14.1/lib/pry/slop.rb:416 + def to_s; end + + private + + # Autocreate an option on the fly. See the :autocreate Slop config option. + # + # items - The Array of items we're parsing. + # index - The current Integer index for the item we're processing. + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop.rb:590 + def autocreate(items, index); end + + # Build an option from a list of objects. + # + # objects - An Array of objects used to build this option. + # + # Returns a new instance of Slop::Option. + # + # source://pry-0.14.1/lib/pry/slop.rb:606 + def build_option(objects, &block); end + + # Remove any leading -- characters from a string. + # + # object - The Object we want to cast to a String and clean. + # + # Returns the newly cleaned String with leading -- characters removed. + # + # source://pry-0.14.1/lib/pry/slop.rb:659 + def clean(object); end + + # source://pry-0.14.1/lib/pry/slop.rb:663 + def commands_to_help; end + + # Execute a `-abc` type option where a, b and c are all options. This + # method is only executed if the multiple_switches argument is true. + # + # option - The first Option object. + # argument - The argument to this option. (Split into multiple Options). + # index - The index of the current item being processed. + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop.rb:552 + def execute_multiple_switches(option, argument, index); end + + # Execute an option, firing off callbacks and assigning arguments. + # + # option - The Slop::Option object found by #process_item. + # argument - The argument Object to assign to this option. + # index - The current Integer index of the object we're processing. + # item - The optional String item we're processing. + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop.rb:519 + def execute_option(option, argument, index, item = T.unsafe(nil)); end + + # Extract the long flag from an item. + # + # objects - The Array of objects passed from #build_option. + # config - The Hash of configuration options built in #build_option. + # + # source://pry-0.14.1/lib/pry/slop.rb:644 + def extract_long_flag(objects, config); end + + # Extract an option from a flag. + # + # flag - The flag key used to extract an option. + # + # Returns an Array of [option, argument]. + # + # source://pry-0.14.1/lib/pry/slop.rb:567 + def extract_option(flag); end + + # Extract the short flag from an item. + # + # objects - The Array of objects passed from #build_option. + # config - The Hash of configuration options built in #build_option. + # + # source://pry-0.14.1/lib/pry/slop.rb:626 + def extract_short_flag(objects, config); end + + # Convenience method for present?(:option). + # + # Examples: + # + # opts.parse %( --verbose ) + # opts.verbose? #=> true + # opts.other? #=> false + # + # Returns true if this option is present. If this method does not end + # with a ? character it will instead call super(). + # + # source://pry-0.14.1/lib/pry/slop.rb:454 + def method_missing(method, *args, &block); end + + # Process a list item, figure out if it's an option, execute any + # callbacks, assign any option arguments, and do some sanity checks. + # + # items - The Array of items to process. + # index - The current Integer index of the item we want to process. + # block - An optional block which when passed will yield non options. + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop.rb:472 + def process_item(items, index, &block); end + + # Override this method so we can check if an option? method exists. + # + # Returns true if this option key exists in our list of options. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop.rb:340 + def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end + + class << self + # Build a Slop object from a option specification. + # + # This allows you to design your options via a simple String rather + # than programatically. Do note though that with this method, you're + # unable to pass any advanced options to the on() method when creating + # options. + # + # string - The optspec String + # config - A Hash of configuration options to pass to Slop.new + # + # Examples: + # + # opts = Slop.optspec(<<-SPEC) + # ruby foo.rb [options] + # --- + # n,name= Your name + # a,age= Your age + # A,auth Sign in with auth + # p,passcode= Your secret pass code + # SPEC + # + # opts.fetch_option(:name).description #=> "Your name" + # + # Returns a new instance of Slop. + # + # source://pry-0.14.1/lib/pry/slop.rb:97 + def optspec(string, config = T.unsafe(nil)); end + + # items - The Array of items to extract options from (default: ARGV). + # config - The Hash of configuration options to send to Slop.new(). + # block - An optional block used to add options. + # + # Examples: + # + # Slop.parse(ARGV, :help => true) do + # on '-n', '--name', 'Your username', :argument => true + # end + # + # Returns a new instance of Slop. + # + # source://pry-0.14.1/lib/pry/slop.rb:54 + def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end + + # items - The Array of items to extract options from (default: ARGV). + # config - The Hash of configuration options to send to Slop.new(). + # block - An optional block used to add options. + # + # Returns a new instance of Slop. + # + # source://pry-0.14.1/lib/pry/slop.rb:63 + def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end + end +end + +# source://pry-0.14.1/lib/pry/slop/commands.rb:5 +class Pry::Slop::Commands + include ::Enumerable + + # Create a new instance of Slop::Commands and optionally build + # Slop instances via a block. Any configuration options used in + # this method will be the default configuration options sent to + # each Slop object created. + # + # config - An optional configuration Hash. + # block - Optional block used to define commands. + # + # Examples: + # + # commands = Slop::Commands.new do + # on :new do + # on '-o', '--outdir=', 'The output directory' + # on '-v', '--verbose', 'Enable verbose mode' + # end + # + # on :generate do + # on '--assets', 'Generate assets', :default => true + # end + # + # global do + # on '-D', '--debug', 'Enable debug mode', :default => false + # end + # end + # + # commands[:new].class #=> Slop + # commands.parse + # + # @return [Commands] a new instance of Commands + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:39 + def initialize(config = T.unsafe(nil), &block); end + + # Fetch the instance of Slop tied to a command. + # + # key - The String or Symbol key used to locate this command. + # + # Returns the Slop instance if this key is found, nil otherwise. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:100 + def [](key); end + + # Returns the value of attribute arguments. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:8 + def arguments; end + + # Optionally set the banner for this command help output. + # + # banner - The String text to set the banner. + # + # Returns the String banner if one is set. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:59 + def banner(banner = T.unsafe(nil)); end + + # Sets the attribute banner + # + # @param value the value to set the attribute banner to. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:9 + def banner=(_arg0); end + + # Returns the value of attribute commands. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:8 + def commands; end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:8 + def config; end + + # Add a Slop instance used when no other commands exist. + # + # config - A Hash of configuration options to pass to Slop. + # block - An optional block used to pass options to Slop. + # + # Returns the newly created Slop instance mapped to default. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:81 + def default(config = T.unsafe(nil), &block); end + + # Enumerable interface. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:119 + def each(&block); end + + # Fetch the instance of Slop tied to a command. + # + # key - The String or Symbol key used to locate this command. + # + # Returns the Slop instance if this key is found, nil otherwise. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:100 + def get(key); end + + # Add a global Slop instance. + # + # config - A Hash of configuration options to pass to Slop. + # block - An optional block used to pass options to Slop. + # + # Returns the newly created Slop instance mapped to global. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:91 + def global(config = T.unsafe(nil), &block); end + + # Returns the help String. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:158 + def help; end + + # Returns the inspection String. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:170 + def inspect; end + + # Add a Slop instance for a specific command. + # + # command - A String or Symbol key used to identify this command. + # config - A Hash of configuration options to pass to Slop. + # block - An optional block used to pass options to Slop. + # + # Returns the newly created Slop instance mapped to command. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:71 + def on(command, config = T.unsafe(nil), &block); end + + # Parse a list of items. + # + # items - The Array of items to parse. + # + # Returns the original Array of items. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:128 + def parse(items = T.unsafe(nil)); end + + # Parse a list of items, removing any options or option arguments found. + # + # items - The Array of items to parse. + # + # Returns the original Array of items with options removed. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:138 + def parse!(items = T.unsafe(nil)); end + + # Check for a command presence. + # + # Examples: + # + # cmds.parse %w( foo ) + # cmds.present?(:foo) #=> true + # cmds.present?(:bar) #=> false + # + # Returns true if the given key is present in the parsed arguments. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:114 + def present?(key); end + + # Returns a nested Hash with Slop options and values. See Slop#to_hash. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:153 + def to_hash; end + + # Returns the help String. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:158 + def to_s; end + + private + + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:177 + def execute_arguments!(items); end + + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop/commands.rb:183 + def execute_global_opts!(items); end +end + +# Returns a default Hash of configuration options this Slop instance uses. +# +# source://pry-0.14.1/lib/pry/slop.rb:30 +Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# The main Error class, all Exception classes inherit from this class. +# +# source://pry-0.14.1/lib/pry/slop.rb:12 +class Pry::Slop::Error < ::StandardError; end + +# Raised when an argument does not match its intended match constraint. +# +# source://pry-0.14.1/lib/pry/slop.rb:21 +class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end + +# Raised when an invalid command is found and the strict flag is enabled. +# +# source://pry-0.14.1/lib/pry/slop.rb:27 +class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end + +# Raised when an invalid option is found and the strict flag is enabled. +# +# source://pry-0.14.1/lib/pry/slop.rb:24 +class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end + +# Raised when an option argument is expected but none are given. +# +# source://pry-0.14.1/lib/pry/slop.rb:15 +class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end + +# Raised when an option is expected/required but not present. +# +# source://pry-0.14.1/lib/pry/slop.rb:18 +class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end + +# source://pry-0.14.1/lib/pry/slop/option.rb:5 +class Pry::Slop::Option + # Incapsulate internal option information, mainly used to store + # option specific configuration data, most of the meat of this + # class is found in the #value method. + # + # slop - The instance of Slop tied to this Option. + # short - The String or Symbol short flag. + # long - The String or Symbol long flag. + # description - The String description text. + # config - A Hash of configuration options. + # block - An optional block used as a callback. + # + # @return [Option] a new instance of Option + # + # source://pry-0.14.1/lib/pry/slop/option.rb:35 + def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end + + # Returns true if this option accepts an optional argument. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop/option.rb:72 + def accepts_optional_argument?; end + + # Returns the value of attribute argument_in_value. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:23 + def argument_in_value; end + + # Sets the attribute argument_in_value + # + # @param value the value to set the attribute argument_in_value to. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:23 + def argument_in_value=(_arg0); end + + # Call this options callback if one exists, and it responds to call(). + # + # Returns nothing. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:84 + def call(*objects); end + + # Returns the value of attribute config. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:22 + def config; end + + # Returns the value of attribute count. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:23 + def count; end + + # Sets the attribute count + # + # @param value the value to set the attribute count to. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:23 + def count=(_arg0); end + + # Returns the value of attribute description. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:22 + def description; end + + # Returns true if this option expects an argument. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/slop/option.rb:67 + def expects_argument?; end + + # Returns the help String for this option. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:124 + def help; end + + # Returns the String inspection text. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:143 + def inspect; end + + # Returns the String flag of this option. Preferring the long flag. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:77 + def key; end + + # Returns the value of attribute long. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:22 + def long; end + + # Returns the value of attribute short. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:22 + def short; end + + # Returns the help String for this option. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:124 + def to_s; end + + # Returns the value of attribute types. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:22 + def types; end + + # Fetch the argument value for this option. + # + # Returns the Object once any type conversions have taken place. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:108 + def value; end + + # Set the new argument value for this option. + # + # We use this setter method to handle concatenating lists. That is, + # when an array type is specified and used more than once, values from + # both options will be grouped together and flattened into a single array. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:93 + def value=(new_value); end + + private + + # Convert an object to a Float if possible. + # + # value - The Object we want to convert to a float. + # + # Returns the Float value if possible to convert, else a zero. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:173 + def value_to_float(value); end + + # Convert an object to an Integer if possible. + # + # value - The Object we want to convert to an integer. + # + # Returns the Integer value if possible to convert, else a zero. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:156 + def value_to_integer(value); end + + # Convert an object to a Range if possible. + # + # value - The Object we want to convert to a range. + # + # Returns the Range value if one could be found, else the original object. + # + # source://pry-0.14.1/lib/pry/slop/option.rb:190 + def value_to_range(value); end +end + +# The default Hash of configuration options this class uses. +# +# source://pry-0.14.1/lib/pry/slop/option.rb:7 +Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# source://pry-0.14.1/lib/pry/slop.rb:9 +Pry::Slop::VERSION = T.let(T.unsafe(nil), String) + +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/syntax_highlighter.rb:8 +class Pry::SyntaxHighlighter + class << self + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/syntax_highlighter.rb:9 + def highlight(code, language = T.unsafe(nil)); end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/syntax_highlighter.rb:17 + def keyword_token_color; end + + # Sets comment token to blue (black by default), so it's more legible. + # + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/syntax_highlighter.rb:22 + def overwrite_coderay_comment_token!; end + + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/syntax_highlighter.rb:13 + def tokenize(code, language = T.unsafe(nil)); end + end +end + +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/system_command_handler.rb:6 +module Pry::SystemCommandHandler + class << self + # @api private + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/system_command_handler.rb:8 + def default(output, command, _pry_instance); end + end +end + +# Catches SecurityErrors if $SAFE is set +# +# source://pry-0.14.1/lib/pry/exceptions.rb:28 +module Pry::TooSafeException + class << self + # source://pry-0.14.1/lib/pry/exceptions.rb:29 + def ===(exception); end + end +end + +# An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error +# in a more user-friendly manner. This should be used when the exception +# happens within Pry itself as a direct consequence of the user typing +# something wrong. +# +# This allows us to distinguish between the user typing: +# +# pry(main)> def ) +# SyntaxError: unexpected ) +# +# pry(main)> method_that_evals("def )") +# SyntaxError: (eval):1: syntax error, unexpected ')' +# from ./a.rb:2 in `eval' +# +# source://pry-0.14.1/lib/pry/exceptions.rb:51 +module Pry::UserError; end + +# source://pry-0.14.1/lib/pry/version.rb:4 +Pry::VERSION = T.let(T.unsafe(nil), String) + +# @api private +# @since v0.13.0 +# +# source://pry-0.14.1/lib/pry/warning.rb:6 +module Pry::Warning + class << self + # Prints a warning message with exact file and line location, similar to how + # Ruby's -W prints warnings. + # + # @api private + # @param message [String] + # @return [void] + # @since v0.13.0 + # + # source://pry-0.14.1/lib/pry/warning.rb:12 + def warn(message); end + end +end + +# source://pry-0.14.1/lib/pry/wrapped_module.rb:16 +class Pry::WrappedModule + include ::Pry::Helpers::BaseHelpers + include ::Pry::CodeObject::Helpers + + # @param mod [Module] + # @raise [ArgumentError] if the argument is not a `Module` + # @return [WrappedModule] a new instance of WrappedModule + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:56 + def initialize(mod); end + + # Return a candidate for this module of specified rank. A `rank` + # of 0 is equivalent to the 'primary candidate', which is the + # module definition with the highest number of methods. A `rank` + # of 1 is the module definition with the second highest number of + # methods, and so on. Module candidates are necessary as modules + # can be reopened multiple times and in multiple places in Ruby, + # the candidate API gives you access to the module definition + # representing each of those reopenings. + # + # @param rank [Fixnum] + # @raise [Pry::CommandError] If the `rank` is out of range. That + # is greater than `number_of_candidates - 1`. + # @return [Pry::WrappedModule::Candidate] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:239 + def candidate(rank); end + + # @note On JRuby 1.9 and higher, in certain conditions, this method chucks + # away its ability to be quick (when there are lots of monkey patches, + # like in Rails). However, it should be efficient enough on other rubies. + # @return [Enumerator, Array] on JRuby 1.9 and higher returns Array, on + # other rubies returns Enumerator + # @see https://github.com/jruby/jruby/issues/525 + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:255 + def candidates; end + + # Is this strictly a class? + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:126 + def class?; end + + # Returns an array of the names of the constants accessible in the wrapped + # module. This avoids the problem of accidentally calling the singleton + # method `Module.constants`. + # + # @param inherit [Boolean] Include the names of constants from included + # modules? + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:76 + def constants(inherit = T.unsafe(nil)); end + + # Returns documentation for the module. + # This documentation is for the primary candidate, if + # you would like documentation for other candidates use + # `WrappedModule#candidate` to select the candidate you're + # interested in. + # + # @raise [Pry::CommandError] If documentation cannot be found. + # @return [String] The documentation for the module. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:195 + def doc; end + + # @return [String, nil] The associated file for the module (i.e + # the primary candidate: highest ranked monkeypatch). + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:176 + def file; end + + # @return [Fixnum, nil] The associated line for the module (i.e + # the primary candidate: highest ranked monkeypatch). + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:183 + def line; end + + # Forward method invocations to the wrapped module + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:150 + def method_missing(method_name, *args, &block); end + + # The prefix that would appear before methods defined on this class. + # + # i.e. the "String." or "String#" in String.new and String#initialize. + # + # @return String + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:85 + def method_prefix; end + + # Is this strictly a module? (does not match classes) + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:120 + def module?; end + + # The name of the Module if it has one, otherwise #. + # + # @return [String] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:100 + def nonblank_name; end + + # @return [Fixnum] The number of candidate definitions for the + # current module. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:245 + def number_of_candidates; end + + # Is this a singleton class? + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:110 + def singleton_class?; end + + # Get the instance associated with this singleton class. + # + # @raise ArgumentError: tried to get instance of non singleton class + # @return [Object] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:135 + def singleton_instance; end + + # Returns the source for the module. + # This source is for the primary candidate, if + # you would like source for other candidates use + # `WrappedModule#candidate` to select the candidate you're + # interested in. + # + # @raise [Pry::CommandError] If source cannot be found. + # @return [String] The source for the module. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:206 + def source; end + + # @return [String, nil] The associated file for the module (i.e + # the primary candidate: highest ranked monkeypatch). + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:176 + def source_file; end + + # @return [Fixnum, nil] The associated line for the module (i.e + # the primary candidate: highest ranked monkeypatch). + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:183 + def source_line; end + + # Retrieve the source location of a module. Return value is in same + # format as Method#source_location. If the source location + # cannot be found this method returns `nil`. + # + # @return [Array, nil] The source location of the + # module (or class), or `nil` if no source location found. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:168 + def source_location; end + + # @param times [Fixnum] How far to travel up the ancestor chain. + # @return [Pry::WrappedModule, nil] The wrapped module that is the + # superclass. + # When `self` is a `Module` then return the + # nth ancestor, otherwise (in the case of classes) return the + # nth ancestor that is a class. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:275 + def super(times = T.unsafe(nil)); end + + # Returns the value of attribute wrapped. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:20 + def wrapped; end + + # @return [String] Return the YARD docs for this module. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:223 + def yard_doc; end + + # @return [Boolean] Whether YARD docs are available for this module. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:265 + def yard_docs?; end + + # @return [String] Return the associated file for the + # module from YARD, if one exists. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:212 + def yard_file; end + + # @return [Fixnum] Return the associated line for the + # module from YARD, if one exists. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:218 + def yard_line; end + + private + + # Return all methods (instance methods and class methods) for a + # given module. + # + # @return [Array] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:352 + def all_methods_for(mod); end + + # We only want methods that have a non-nil `source_location`. We also + # skip some spooky internal methods. + # + # @return [Array] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:334 + def all_relevant_methods_for(mod); end + + # A helper method. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:315 + def all_source_locations_by_popularity; end + + # memoized lines for file + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:376 + def lines_for_file(file); end + + # @return [Array>] The array of `Pry::Method` objects, + # there are two associated with each candidate. The first is the 'base + # method' for a candidate and it serves as the start point for + # the search in uncovering the module definition. The second is + # the last method defined for that candidate and it is used to + # speed up source code extraction. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:307 + def method_candidates; end + + # Detect methods that are defined with `def_delegator` from the Forwardable + # module. We want to reject these methods as they screw up module + # extraction since the `source_location` for such methods points at forwardable.rb + # TODO: make this more robust as valid user-defined files called + # forwardable.rb are also skipped. + # + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:371 + def method_defined_by_forwardable_module?(method); end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:356 + def nested_module?(parent, name); end + + # @return [Pry::WrappedModule::Candidate] The candidate with the + # highest rank, that is the 'monkey patch' of this module with the + # highest number of methods, which contains a source code line that + # defines the module. It is considered the 'canonical' definition + # for the module. In the absense of a suitable candidate, the + # candidate of rank 0 will be returned, or a CommandError raised if + # there are no candidates at all. + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:297 + def primary_candidate; end + + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:158 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end + + class << self + # Convert a string to a module. + # + # @example + # Pry::WrappedModule.from_str("Pry::Code") + # @param mod_name [String] + # @param target [Binding] The binding where the lookup takes place. + # @return [Module, nil] The module or `nil` (if conversion failed). + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:29 + def from_str(mod_name, target = T.unsafe(nil)); end + + private + + # We use this method to decide whether code is safe to eval. Method's are + # generally not, but everything else is. + # TODO: is just checking != "method" enough?? + # TODO: see duplication of this method in Pry::CodeObject + # + # @param str [String] The string to lookup. + # @param target [Binding] Where the lookup takes place. + # @return [Boolean] + # + # source://pry-0.14.1/lib/pry/wrapped_module.rb:45 + def safe_to_evaluate?(str, target); end + end +end + +# This class represents a single candidate for a module/class definition. +# It provides access to the source, documentation, line and file +# for a monkeypatch (reopening) of a class/module. +# +# source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:8 +class Pry::WrappedModule::Candidate + include ::Pry::Helpers::DocumentationHelpers + include ::Pry::CodeObject::Helpers + extend ::Forwardable + extend ::Pry::Forwardable + + # @param wrapper [Pry::WrappedModule] The associated + # `Pry::WrappedModule` instance that owns the candidates. + # @param rank [Fixnum] The rank of the candidate to + # retrieve. Passing 0 returns 'primary candidate' (the candidate with largest + # number of methods), passing 1 retrieves candidate with + # second largest number of methods, and so on, up to + # `Pry::WrappedModule#number_of_candidates() - 1` + # @raise [Pry::CommandError] If `rank` is out of bounds. + # @return [Candidate] a new instance of Candidate + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:38 + def initialize(wrapper, rank); end + + # source://RUBY_ROOT/forwardable.rb:226 + def class?(*args, &block); end + + # @raise [Pry::CommandError] If documentation cannot be found. + # @return [String] The documentation for the candidate. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:70 + def doc; end + + # @return [String] The file where the module definition is located. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:14 + def file; end + + # @return [Fixnum] The line where the module definition is located. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:18 + def line; end + + # source://RUBY_ROOT/forwardable.rb:226 + def module?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def nonblank_name(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def number_of_candidates(*args, &block); end + + # @raise [Pry::CommandError] If source code cannot be found. + # @return [String] The source for the candidate, i.e the + # complete module/class definition. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:59 + def source; end + + # @return [String] The file where the module definition is located. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:14 + def source_file; end + + # @return [Fixnum] The line where the module definition is located. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:18 + def source_line; end + + # @return [Array, nil] A `[String, Fixnum]` pair representing the + # source location (file and line) for the candidate or `nil` + # if no source location found. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:79 + def source_location; end + + # source://RUBY_ROOT/forwardable.rb:226 + def wrapped(*args, &block); end + + private + + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:104 + def class_regexes; end + + # Locate the first line of the module definition. + # + # @param file [String] The file that contains the module + # definition (somewhere). + # @param line [Fixnum] The module definition should appear + # before this line (if it exists). + # @return [Fixnum] The line where the module is defined. This + # line number is one-indexed. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:99 + def first_line_of_module_definition(file, line); end + + # This method is used by `Candidate#source_location` as a + # starting point for the search for the candidate's definition. + # + # @return [Array] The source location of the base method used to + # calculate the source location of the candidate. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:115 + def first_method_source_location; end + + # @return [Array] The source location of the last method in this + # candidate's module definition. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:121 + def last_method_source_location; end + + # source://pry-0.14.1/lib/pry/forwardable.rb:18 + def lines_for_file(*a, &b); end + + # source://pry-0.14.1/lib/pry/forwardable.rb:18 + def method_candidates(*a, &b); end + + # source://pry-0.14.1/lib/pry/forwardable.rb:18 + def name(*a, &b); end + + # Return the number of lines between the start of the class definition and + # the start of the last method. We use this value so we can quickly grab + # these lines from the file (without having to check each intervening line + # for validity, which is expensive) speeding up source extraction. + # + # @return [Integer] number of lines. + # + # source://pry-0.14.1/lib/pry/wrapped_module/candidate.rb:131 + def number_of_lines_in_first_chunk; end + + # source://pry-0.14.1/lib/pry/forwardable.rb:18 + def yard_docs?(*a, &b); end +end diff --git a/sorbet/rbi/gems/rainbow.rbi b/sorbet/rbi/gems/rainbow.rbi deleted file mode 100644 index 64c3036a..00000000 --- a/sorbet/rbi/gems/rainbow.rbi +++ /dev/null @@ -1,122 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rainbow/all/rainbow.rbi -# -# rainbow-3.1.1 - -module Rainbow - def self.enabled; end - def self.enabled=(value); end - def self.global; end - def self.new; end - def self.uncolor(string); end -end -class Rainbow::StringUtils - def self.uncolor(string); end - def self.wrap_with_sgr(string, codes); end -end -module Rainbow::X11ColorNames -end -class Rainbow::Color - def ground; end - def self.build(ground, values); end - def self.parse_hex_color(hex); end -end -class Rainbow::Color::Indexed < Rainbow::Color - def codes; end - def initialize(ground, num); end - def num; end -end -class Rainbow::Color::Named < Rainbow::Color::Indexed - def initialize(ground, name); end - def self.color_names; end - def self.valid_names; end -end -class Rainbow::Color::RGB < Rainbow::Color::Indexed - def b; end - def code_from_rgb; end - def codes; end - def g; end - def initialize(ground, *values); end - def r; end - def self.to_ansi_domain(value); end -end -class Rainbow::Color::X11Named < Rainbow::Color::RGB - def initialize(ground, name); end - def self.color_names; end - def self.valid_names; end - include Rainbow::X11ColorNames -end -class Rainbow::Presenter < String - def background(*values); end - def bg(*values); end - def black; end - def blink; end - def blue; end - def bold; end - def bright; end - def color(*values); end - def cross_out; end - def cyan; end - def dark; end - def faint; end - def fg(*values); end - def foreground(*values); end - def green; end - def hide; end - def inverse; end - def italic; end - def magenta; end - def method_missing(method_name, *args); end - def red; end - def reset; end - def respond_to_missing?(method_name, *args); end - def strike; end - def underline; end - def white; end - def wrap_with_sgr(codes); end - def yellow; end -end -class Rainbow::NullPresenter < String - def background(*_values); end - def bg(*_values); end - def black; end - def blink; end - def blue; end - def bold; end - def bright; end - def color(*_values); end - def cross_out; end - def cyan; end - def dark; end - def faint; end - def fg(*_values); end - def foreground(*_values); end - def green; end - def hide; end - def inverse; end - def italic; end - def magenta; end - def method_missing(method_name, *args); end - def red; end - def reset; end - def respond_to_missing?(method_name, *args); end - def strike; end - def underline; end - def white; end - def yellow; end -end -class Rainbow::Wrapper - def enabled; end - def enabled=(arg0); end - def initialize(enabled = nil); end - def wrap(string); end -end -class Object < BasicObject - def Rainbow(string); end -end diff --git a/sorbet/rbi/gems/rainbow@3.1.1.rbi b/sorbet/rbi/gems/rainbow@3.1.1.rbi new file mode 100644 index 00000000..b2c2b71f --- /dev/null +++ b/sorbet/rbi/gems/rainbow@3.1.1.rbi @@ -0,0 +1,404 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rainbow` gem. +# Please instead update this file by running `bin/tapioca gem rainbow`. + +# source://yard-0.9.28/lib/yard.rb:62 +::RUBY19 = T.let(T.unsafe(nil), TrueClass) + +class Object < ::BasicObject + include ::Kernel + + private + + # source://rainbow-3.1.1/lib/rainbow/global.rb:23 + def Rainbow(string); end +end + +# source://rainbow-3.1.1/lib/rainbow/string_utils.rb:3 +module Rainbow + class << self + # source://rainbow-3.1.1/lib/rainbow/global.rb:10 + def enabled; end + + # source://rainbow-3.1.1/lib/rainbow/global.rb:14 + def enabled=(value); end + + # source://rainbow-3.1.1/lib/rainbow/global.rb:6 + def global; end + + # source://rainbow-3.1.1/lib/rainbow.rb:6 + def new; end + + # source://rainbow-3.1.1/lib/rainbow/global.rb:18 + def uncolor(string); end + end +end + +# source://rainbow-3.1.1/lib/rainbow/color.rb:4 +class Rainbow::Color + # Returns the value of attribute ground. + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:5 + def ground; end + + class << self + # source://rainbow-3.1.1/lib/rainbow/color.rb:7 + def build(ground, values); end + + # source://rainbow-3.1.1/lib/rainbow/color.rb:40 + def parse_hex_color(hex); end + end +end + +# source://rainbow-3.1.1/lib/rainbow/color.rb:54 +class Rainbow::Color::Indexed < ::Rainbow::Color + # @return [Indexed] a new instance of Indexed + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:57 + def initialize(ground, num); end + + # source://rainbow-3.1.1/lib/rainbow/color.rb:62 + def codes; end + + # Returns the value of attribute num. + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:55 + def num; end +end + +# source://rainbow-3.1.1/lib/rainbow/color.rb:69 +class Rainbow::Color::Named < ::Rainbow::Color::Indexed + # @return [Named] a new instance of Named + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:90 + def initialize(ground, name); end + + class << self + # source://rainbow-3.1.1/lib/rainbow/color.rb:82 + def color_names; end + + # source://rainbow-3.1.1/lib/rainbow/color.rb:86 + def valid_names; end + end +end + +# source://rainbow-3.1.1/lib/rainbow/color.rb:70 +Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash) + +# source://rainbow-3.1.1/lib/rainbow/color.rb:100 +class Rainbow::Color::RGB < ::Rainbow::Color::Indexed + # @return [RGB] a new instance of RGB + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:107 + def initialize(ground, *values); end + + # Returns the value of attribute b. + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:101 + def b; end + + # source://rainbow-3.1.1/lib/rainbow/color.rb:116 + def codes; end + + # Returns the value of attribute g. + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:101 + def g; end + + # Returns the value of attribute r. + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:101 + def r; end + + private + + # source://rainbow-3.1.1/lib/rainbow/color.rb:122 + def code_from_rgb; end + + class << self + # source://rainbow-3.1.1/lib/rainbow/color.rb:103 + def to_ansi_domain(value); end + end +end + +# source://rainbow-3.1.1/lib/rainbow/color.rb:129 +class Rainbow::Color::X11Named < ::Rainbow::Color::RGB + include ::Rainbow::X11ColorNames + + # @return [X11Named] a new instance of X11Named + # + # source://rainbow-3.1.1/lib/rainbow/color.rb:140 + def initialize(ground, name); end + + class << self + # source://rainbow-3.1.1/lib/rainbow/color.rb:132 + def color_names; end + + # source://rainbow-3.1.1/lib/rainbow/color.rb:136 + def valid_names; end + end +end + +# source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:4 +class Rainbow::NullPresenter < ::String + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:9 + def background(*_values); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:9 + def bg(*_values); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:49 + def black; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:33 + def blink; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:65 + def blue; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:17 + def bold; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:17 + def bright; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:5 + def color(*_values); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:45 + def cross_out; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:73 + def cyan; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:21 + def dark; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:21 + def faint; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:5 + def fg(*_values); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:5 + def foreground(*_values); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:57 + def green; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:41 + def hide; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:37 + def inverse; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:25 + def italic; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:69 + def magenta; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:81 + def method_missing(method_name, *args); end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:53 + def red; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:13 + def reset; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:45 + def strike; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:29 + def underline; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:77 + def white; end + + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:61 + def yellow; end + + private + + # @return [Boolean] + # + # source://rainbow-3.1.1/lib/rainbow/null_presenter.rb:89 + def respond_to_missing?(method_name, *args); end +end + +# source://rainbow-3.1.1/lib/rainbow/presenter.rb:8 +class Rainbow::Presenter < ::String + # Sets background color of this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:30 + def background(*values); end + + # Sets background color of this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:30 + def bg(*values); end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:92 + def black; end + + # Turns on blinking attribute for this text (not well supported by terminal + # emulators). + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:72 + def blink; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:108 + def blue; end + + # Turns on bright/bold for this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:45 + def bold; end + + # Turns on bright/bold for this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:45 + def bright; end + + # Sets color of this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:22 + def color(*values); end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:86 + def cross_out; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:116 + def cyan; end + + # Turns on faint/dark for this text (not well supported by terminal + # emulators). + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:53 + def dark; end + + # Turns on faint/dark for this text (not well supported by terminal + # emulators). + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:53 + def faint; end + + # Sets color of this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:22 + def fg(*values); end + + # Sets color of this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:22 + def foreground(*values); end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:100 + def green; end + + # Hides this text (set its color to the same as background). + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:82 + def hide; end + + # Inverses current foreground/background colors. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:77 + def inverse; end + + # Turns on italic style for this text (not well supported by terminal + # emulators). + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:61 + def italic; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:112 + def magenta; end + + # We take care of X11 color method call here. + # Such as #aqua, #ghostwhite. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:126 + def method_missing(method_name, *args); end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:96 + def red; end + + # Resets terminal to default colors/backgrounds. + # + # It shouldn't be needed to use this method because all methods + # append terminal reset code to end of string. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:40 + def reset; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:86 + def strike; end + + # Turns on underline decoration for this text. + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:66 + def underline; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:120 + def white; end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:104 + def yellow; end + + private + + # @return [Boolean] + # + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:134 + def respond_to_missing?(method_name, *args); end + + # source://rainbow-3.1.1/lib/rainbow/presenter.rb:140 + def wrap_with_sgr(codes); end +end + +# source://rainbow-3.1.1/lib/rainbow/presenter.rb:9 +Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash) + +# source://rainbow-3.1.1/lib/rainbow/string_utils.rb:4 +class Rainbow::StringUtils + class << self + # source://rainbow-3.1.1/lib/rainbow/string_utils.rb:17 + def uncolor(string); end + + # source://rainbow-3.1.1/lib/rainbow/string_utils.rb:5 + def wrap_with_sgr(string, codes); end + end +end + +# source://rainbow-3.1.1/lib/rainbow/wrapper.rb:7 +class Rainbow::Wrapper + # @return [Wrapper] a new instance of Wrapper + # + # source://rainbow-3.1.1/lib/rainbow/wrapper.rb:10 + def initialize(enabled = T.unsafe(nil)); end + + # Returns the value of attribute enabled. + # + # source://rainbow-3.1.1/lib/rainbow/wrapper.rb:8 + def enabled; end + + # Sets the attribute enabled + # + # @param value the value to set the attribute enabled to. + # + # source://rainbow-3.1.1/lib/rainbow/wrapper.rb:8 + def enabled=(_arg0); end + + # source://rainbow-3.1.1/lib/rainbow/wrapper.rb:14 + def wrap(string); end +end + +# source://rainbow-3.1.1/lib/rainbow/x11_color_names.rb:4 +module Rainbow::X11ColorNames; end + +# source://rainbow-3.1.1/lib/rainbow/x11_color_names.rb:5 +Rainbow::X11ColorNames::NAMES = T.let(T.unsafe(nil), Hash) diff --git a/sorbet/rbi/gems/rake.rbi b/sorbet/rbi/gems/rake.rbi deleted file mode 100644 index b8c4873a..00000000 --- a/sorbet/rbi/gems/rake.rbi +++ /dev/null @@ -1,645 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rake/all/rake.rbi -# -# rake-13.0.6 - -module Rake - def self.add_rakelib(*files); end - def self.application; end - def self.application=(app); end - def self.each_dir_parent(dir); end - def self.from_pathname(path); end - def self.load_rakefile(path); end - def self.original_dir; end - def self.suggested_thread_count; end - def self.with_application(block_application = nil); end - extend Rake::FileUtilsExt -end -module Rake::Version -end -class Module - def rake_extension(method); end -end -class String - def ext(newext = nil); end - def pathmap(spec = nil, &block); end - def pathmap_explode; end - def pathmap_partial(n); end - def pathmap_replace(patterns, &block); end -end -module Rake::Win32 - def self.normalize(path); end - def self.win32_system_dir; end - def self.windows?; end -end -class Rake::Win32::Win32HomeError < RuntimeError -end -class Rake::LinkedList - def ==(other); end - def conj(item); end - def each; end - def empty?; end - def head; end - def initialize(head, tail = nil); end - def inspect; end - def self.cons(head, tail); end - def self.empty; end - def self.make(*args); end - def tail; end - def to_s; end - include Enumerable -end -class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList - def empty?; end - def initialize; end - def self.cons(head, tail); end -end -class Rake::CpuCounter - def count; end - def count_with_default(default = nil); end - def self.count; end -end -class Rake::Scope < Rake::LinkedList - def path; end - def path_with_task_name(task_name); end - def trim(n); end -end -class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList - def path; end - def path_with_task_name(task_name); end -end -class Rake::TaskArgumentError < ArgumentError -end -class Rake::RuleRecursionOverflowError < StandardError - def add_target(target); end - def initialize(*args); end - def message; end -end -module Rake::TaskManager - def [](task_name, scopes = nil); end - def add_location(task); end - def attempt_rule(task_name, task_pattern, args, extensions, block, level); end - def clear; end - def create_rule(*args, &block); end - def current_scope; end - def define_task(task_class, *args, &block); end - def enhance_with_matching_rule(task_name, level = nil); end - def find_location; end - def generate_did_you_mean_suggestions(task_name); end - def generate_message_for_undefined_task(task_name); end - def generate_name; end - def get_description(task); end - def in_namespace(name); end - def initialize; end - def intern(task_class, task_name); end - def last_description; end - def last_description=(arg0); end - def lookup(task_name, initial_scope = nil); end - def lookup_in_scope(name, scope); end - def make_sources(task_name, task_pattern, extensions); end - def resolve_args(args); end - def resolve_args_with_dependencies(args, hash); end - def resolve_args_without_dependencies(args); end - def self.record_task_metadata; end - def self.record_task_metadata=(arg0); end - def synthesize_file_task(task_name); end - def tasks; end - def tasks_in_scope(scope); end - def trace_rule(level, message); end -end -module Rake::Cloneable - def initialize_copy(source); end -end -module FileUtils - def create_shell_runner(cmd); end - def ruby(*args, **options, &block); end - def safe_ln(*args, **options); end - def set_verbose_option(options); end - def sh(*cmd, &block); end - def sh_show_command(cmd); end - def split_all(path); end -end -module Rake::FileUtilsExt - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def mv(*args, **options, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def safe_unlink(*args, **options, &block); end - def self.nowrite_flag; end - def self.nowrite_flag=(arg0); end - def self.verbose_flag; end - def self.verbose_flag=(arg0); end - def symlink(*args, **options, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - extend Rake::FileUtilsExt - include FileUtils -end -class Rake::FileList - def &(*args, &block); end - def *(other); end - def +(*args, &block); end - def -(*args, &block); end - def <<(obj); end - def <=>(*args, &block); end - def ==(array); end - def [](*args, &block); end - def []=(*args, &block); end - def add(*filenames); end - def add_matching(pattern); end - def all?(*args, &block); end - def any?(*args, &block); end - def append(*args, &block); end - def assoc(*args, &block); end - def at(*args, &block); end - def bsearch(*args, &block); end - def bsearch_index(*args, &block); end - def chain(*args, &block); end - def chunk(*args, &block); end - def chunk_while(*args, &block); end - def clear(*args, &block); end - def clear_exclude; end - def collect!(*args, &block); end - def collect(*args, &block); end - def collect_concat(*args, &block); end - def combination(*args, &block); end - def compact!(*args, &block); end - def compact(*args, &block); end - def concat(*args, &block); end - def count(*args, &block); end - def cycle(*args, &block); end - def deconstruct(*args, &block); end - def delete(*args, &block); end - def delete_at(*args, &block); end - def delete_if(*args, &block); end - def detect(*args, &block); end - def difference(*args, &block); end - def dig(*args, &block); end - def drop(*args, &block); end - def drop_while(*args, &block); end - def each(*args, &block); end - def each_cons(*args, &block); end - def each_entry(*args, &block); end - def each_index(*args, &block); end - def each_slice(*args, &block); end - def each_with_index(*args, &block); end - def each_with_object(*args, &block); end - def egrep(pattern, *options); end - def empty?(*args, &block); end - def entries(*args, &block); end - def exclude(*patterns, &block); end - def excluded_from_list?(fn); end - def existing!; end - def existing; end - def ext(newext = nil); end - def fetch(*args, &block); end - def fill(*args, &block); end - def filter!(*args, &block); end - def filter(*args, &block); end - def filter_map(*args, &block); end - def find(*args, &block); end - def find_all(*args, &block); end - def find_index(*args, &block); end - def first(*args, &block); end - def flat_map(*args, &block); end - def flatten!(*args, &block); end - def flatten(*args, &block); end - def grep(*args, &block); end - def grep_v(*args, &block); end - def group_by(*args, &block); end - def gsub!(pat, rep); end - def gsub(pat, rep); end - def import(array); end - def include(*filenames); end - def include?(*args, &block); end - def index(*args, &block); end - def initialize(*patterns); end - def inject(*args, &block); end - def insert(*args, &block); end - def inspect(*args, &block); end - def intersection(*args, &block); end - def is_a?(klass); end - def join(*args, &block); end - def keep_if(*args, &block); end - def kind_of?(klass); end - def last(*args, &block); end - def lazy(*args, &block); end - def length(*args, &block); end - def map!(*args, &block); end - def map(*args, &block); end - def max(*args, &block); end - def max_by(*args, &block); end - def member?(*args, &block); end - def min(*args, &block); end - def min_by(*args, &block); end - def minmax(*args, &block); end - def minmax_by(*args, &block); end - def none?(*args, &block); end - def one?(*args, &block); end - def pack(*args, &block); end - def partition(&block); end - def pathmap(spec = nil, &block); end - def permutation(*args, &block); end - def pop(*args, &block); end - def prepend(*args, &block); end - def product(*args, &block); end - def push(*args, &block); end - def rassoc(*args, &block); end - def reduce(*args, &block); end - def reject!(*args, &block); end - def reject(*args, &block); end - def repeated_combination(*args, &block); end - def repeated_permutation(*args, &block); end - def replace(*args, &block); end - def resolve; end - def resolve_add(fn); end - def resolve_exclude; end - def reverse!(*args, &block); end - def reverse(*args, &block); end - def reverse_each(*args, &block); end - def rindex(*args, &block); end - def rotate!(*args, &block); end - def rotate(*args, &block); end - def sample(*args, &block); end - def select!(*args, &block); end - def select(*args, &block); end - def self.[](*args); end - def self.glob(pattern, *args); end - def shelljoin(*args, &block); end - def shift(*args, &block); end - def shuffle!(*args, &block); end - def shuffle(*args, &block); end - def size(*args, &block); end - def slice!(*args, &block); end - def slice(*args, &block); end - def slice_after(*args, &block); end - def slice_before(*args, &block); end - def slice_when(*args, &block); end - def sort!(*args, &block); end - def sort(*args, &block); end - def sort_by!(*args, &block); end - def sort_by(*args, &block); end - def sub!(pat, rep); end - def sub(pat, rep); end - def sum(*args, &block); end - def take(*args, &block); end - def take_while(*args, &block); end - def tally(*args, &block); end - def to_a; end - def to_ary; end - def to_h(*args, &block); end - def to_s; end - def to_set(*args, &block); end - def transpose(*args, &block); end - def union(*args, &block); end - def uniq!(*args, &block); end - def uniq(*args, &block); end - def unshift(*args, &block); end - def values_at(*args, &block); end - def zip(*args, &block); end - def |(*args, &block); end - include Rake::Cloneable -end -class Rake::Promise - def chore; end - def complete?; end - def discard; end - def error?; end - def initialize(args, &block); end - def recorder; end - def recorder=(arg0); end - def result?; end - def stat(*args); end - def value; end - def work; end -end -class Rake::ThreadPool - def __queue__; end - def future(*args, &block); end - def gather_history; end - def history; end - def initialize(thread_count); end - def join; end - def process_queue_item; end - def safe_thread_count; end - def start_thread; end - def stat(event, data = nil); end - def statistics; end -end -module Rake::PrivateReader - def self.included(base); end -end -module Rake::PrivateReader::ClassMethods - def private_reader(*names); end -end -class Rake::ThreadHistoryDisplay - def initialize(stats); end - def items; end - def rename(hash, key, renames); end - def show; end - def stats; end - def threads; end - extend Rake::PrivateReader::ClassMethods - include Rake::PrivateReader -end -module Rake::TraceOutput - def trace_on(out, *strings); end -end -class Rake::CommandLineOptionError < StandardError -end -class Rake::Application - def add_import(fn); end - def add_loader(ext, loader); end - def collect_command_line_tasks(args); end - def default_task_name; end - def deprecate(old_usage, new_usage, call_site); end - def display_cause_details(ex); end - def display_error_message(ex); end - def display_exception_backtrace(ex); end - def display_exception_details(ex); end - def display_exception_details_seen; end - def display_exception_message_details(ex); end - def display_prerequisites; end - def display_tasks_and_comments; end - def dynamic_width; end - def dynamic_width_stty; end - def dynamic_width_tput; end - def exit_because_of_exception(ex); end - def find_rakefile_location; end - def glob(path, &block); end - def handle_options(argv); end - def has_cause?(ex); end - def has_chain?(exception); end - def have_rakefile; end - def init(app_name = nil, argv = nil); end - def initialize; end - def invoke_task(task_string); end - def load_imports; end - def load_rakefile; end - def name; end - def options; end - def original_dir; end - def parse_task_string(string); end - def print_rakefile_directory(location); end - def rake_require(file_name, paths = nil, loaded = nil); end - def rakefile; end - def rakefile_location(backtrace = nil); end - def raw_load_rakefile; end - def run(argv = nil); end - def run_with_threads; end - def select_tasks_to_show(options, show_tasks, value); end - def select_trace_output(options, trace_option, value); end - def set_default_options; end - def sort_options(options); end - def standard_exception_handling; end - def standard_rake_options; end - def standard_system_dir; end - def system_dir; end - def terminal_columns; end - def terminal_columns=(arg0); end - def terminal_width; end - def thread_pool; end - def top_level; end - def top_level_tasks; end - def trace(*strings); end - def truncate(string, width); end - def truncate_output?; end - def tty_output=(arg0); end - def tty_output?; end - def unix?; end - def windows?; end - include Rake::TaskManager - include Rake::TraceOutput -end -class Rake::PseudoStatus - def >>(n); end - def exited?; end - def exitstatus; end - def initialize(code = nil); end - def stopped?; end - def to_i; end -end -class Rake::TaskArguments - def [](index); end - def each(&block); end - def extras; end - def fetch(*args, &block); end - def has_key?(key); end - def initialize(names, values, parent = nil); end - def inspect; end - def key?(key); end - def lookup(name); end - def method_missing(sym, *args); end - def names; end - def new_scope(names); end - def to_a; end - def to_hash; end - def to_s; end - def values_at(*keys); end - def with_defaults(defaults); end - include Enumerable -end -class Rake::InvocationChain < Rake::LinkedList - def append(invocation); end - def member?(invocation); end - def prefix; end - def self.append(invocation, chain); end - def to_s; end -end -class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList - def append(invocation); end - def member?(obj); end - def to_s; end -end -module Rake::InvocationExceptionMixin - def chain; end - def chain=(value); end -end -class Rake::Task - def actions; end - def add_chain_to(exception, new_chain); end - def add_comment(comment); end - def add_description(description); end - def all_prerequisite_tasks; end - def already_invoked; end - def application; end - def application=(arg0); end - def arg_description; end - def arg_names; end - def clear; end - def clear_actions; end - def clear_args; end - def clear_comments; end - def clear_prerequisites; end - def collect_prerequisites(seen); end - def comment; end - def comment=(comment); end - def enhance(deps = nil, &block); end - def execute(args = nil); end - def first_sentence(string); end - def format_trace_flags; end - def full_comment; end - def initialize(task_name, app); end - def inspect; end - def investigation; end - def invoke(*args); end - def invoke_prerequisites(task_args, invocation_chain); end - def invoke_prerequisites_concurrently(task_args, invocation_chain); end - def invoke_with_call_chain(task_args, invocation_chain); end - def locations; end - def lookup_prerequisite(prerequisite_name); end - def name; end - def name_with_args; end - def needed?; end - def order_only_prerequisites; end - def prereqs; end - def prerequisite_tasks; end - def prerequisites; end - def reenable; end - def scope; end - def self.[](task_name); end - def self.clear; end - def self.create_rule(*args, &block); end - def self.define_task(*args, &block); end - def self.format_deps(deps); end - def self.scope_name(scope, task_name); end - def self.task_defined?(task_name); end - def self.tasks; end - def set_arg_names(args); end - def source; end - def sources; end - def sources=(arg0); end - def timestamp; end - def to_s; end - def transform_comments(separator, &block); end - def |(deps); end -end -class Rake::EarlyTime - def <=>(other); end - def self.allocate; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::FileTask < Rake::Task - def needed?; end - def out_of_date?(stamp); end - def self.scope_name(scope, task_name); end - def timestamp; end -end -class Rake::FileCreationTask < Rake::FileTask - def needed?; end - def timestamp; end -end -class Rake::MultiTask < Rake::Task - def invoke_prerequisites(task_args, invocation_chain); end -end -module Rake::DSL - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def desc(description); end - def directory(*args, &block); end - def file(*args, &block); end - def file_create(*args, &block); end - def import(*fns); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def multitask(*args, &block); end - def mv(*args, **options, &block); end - def namespace(name = nil, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def ruby(*args, **options, &block); end - def rule(*args, &block); end - def safe_ln(*args, **options); end - def safe_unlink(*args, **options, &block); end - def sh(*cmd, &block); end - def split_all(path); end - def symlink(*args, **options, &block); end - def task(*args, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - include Rake::FileUtilsExt -end -class Rake::DefaultLoader - def load(fn); end -end -class Rake::LateTime - def <=>(other); end - def self.allocate; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::NameSpace - def [](name); end - def initialize(task_manager, scope_list); end - def scope; end - def tasks; end -end -module Rake::Backtrace - def self.collapse(backtrace); end -end diff --git a/sorbet/rbi/gems/rake@13.0.6.rbi b/sorbet/rbi/gems/rake@13.0.6.rbi new file mode 100644 index 00000000..9564e905 --- /dev/null +++ b/sorbet/rbi/gems/rake@13.0.6.rbi @@ -0,0 +1,2884 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rake` gem. +# Please instead update this file by running `bin/tapioca gem rake`. + +# :stopdoc: +# +# Some top level Constants. +# +# source://rake-13.0.6/lib/rake.rb:70 +FileList = Rake::FileList + +# -- +# This a FileUtils extension that defines several additional commands to be +# added to the FileUtils utility functions. +# +# source://rake-13.0.6/lib/rake/file_utils.rb:8 +module FileUtils + # Run a Ruby interpreter with the given arguments. + # + # Example: + # ruby %{-pe '$_.upcase!' ; rm # -rf /. + # + # If a block is given, upon command completion the block is called with an + # OK flag (true on a zero exit status) and a Process::Status object. + # Without a block a RuntimeError is raised when the command exits non-zero. + # + # Examples: + # + # sh 'ls -ltr' + # + # sh 'ls', 'file with spaces' + # + # # check exit status after command runs + # sh %{grep pattern file} do |ok, res| + # if !ok + # puts "pattern not found (status = #{res.exitstatus})" + # end + # end + # + # source://rake-13.0.6/lib/rake/file_utils.rb:43 + def sh(*cmd, &block); end + + # Split a file path into individual directory names. + # + # Example: + # split_all("a/b/c") => ['a', 'b', 'c'] + # + # source://rake-13.0.6/lib/rake/file_utils.rb:128 + def split_all(path); end + + private + + # source://rake-13.0.6/lib/rake/file_utils.rb:61 + def create_shell_runner(cmd); end + + # source://rake-13.0.6/lib/rake/file_utils.rb:86 + def set_verbose_option(options); end + + # source://rake-13.0.6/lib/rake/file_utils.rb:73 + def sh_show_command(cmd); end +end + +# source://rake-13.0.6/lib/rake/file_utils.rb:108 +FileUtils::LN_SUPPORTED = T.let(T.unsafe(nil), Array) + +# Path to the currently running Ruby program +# +# source://rake-13.0.6/lib/rake/file_utils.rb:10 +FileUtils::RUBY = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/ext/core.rb:2 +class Module + # Check for an existing method in the current class before extending. If + # the method already exists, then a warning is printed and the extension is + # not added. Otherwise the block is yielded and any definitions in the + # block will take effect. + # + # Usage: + # + # class String + # rake_extension("xyz") do + # def xyz + # ... + # end + # end + # end + # + # source://rake-13.0.6/lib/rake/ext/core.rb:18 + def rake_extension(method); end +end + +# source://rake-13.0.6/lib/rake.rb:24 +module Rake + extend ::FileUtils::StreamUtils_ + extend ::FileUtils + extend ::Rake::FileUtilsExt + + class << self + # Add files to the rakelib list + # + # source://rake-13.0.6/lib/rake/rake_module.rb:33 + def add_rakelib(*files); end + + # Current Rake Application + # + # source://rake-13.0.6/lib/rake/rake_module.rb:8 + def application; end + + # Set the current Rake application object. + # + # source://rake-13.0.6/lib/rake/rake_module.rb:13 + def application=(app); end + + # Yield each file or directory component. + # + # source://rake-13.0.6/lib/rake/file_list.rb:418 + def each_dir_parent(dir); end + + # Convert Pathname and Pathname-like objects to strings; + # leave everything else alone + # + # source://rake-13.0.6/lib/rake/file_list.rb:429 + def from_pathname(path); end + + # Load a rakefile. + # + # source://rake-13.0.6/lib/rake/rake_module.rb:28 + def load_rakefile(path); end + + # Return the original directory where the Rake application was started. + # + # source://rake-13.0.6/lib/rake/rake_module.rb:23 + def original_dir; end + + # source://rake-13.0.6/lib/rake/rake_module.rb:17 + def suggested_thread_count; end + + # Make +block_application+ the default rake application inside a block so + # you can load rakefiles into a different application. + # + # This is useful when you want to run rake tasks inside a library without + # running rake in a sub-shell. + # + # Example: + # + # Dir.chdir 'other/directory' + # + # other_rake = Rake.with_application do |rake| + # rake.load_rakefile + # end + # + # puts other_rake.tasks + # + # source://rake-13.0.6/lib/rake/rake_module.rb:54 + def with_application(block_application = T.unsafe(nil)); end + end +end + +# Rake main application object. When invoking +rake+ from the +# command line, a Rake::Application object is created and run. +# +# source://rake-13.0.6/lib/rake/application.rb:19 +class Rake::Application + include ::Rake::TaskManager + include ::Rake::TraceOutput + + # Initialize a Rake::Application object. + # + # @return [Application] a new instance of Application + # + # source://rake-13.0.6/lib/rake/application.rb:49 + def initialize; end + + # Add a file to the list of files to be imported. + # + # source://rake-13.0.6/lib/rake/application.rb:777 + def add_import(fn); end + + # Add a loader to handle imported files ending in the extension + # +ext+. + # + # source://rake-13.0.6/lib/rake/application.rb:139 + def add_loader(ext, loader); end + + # Collect the list of tasks on the command line. If no tasks are + # given, return a list containing only the default task. + # Environmental assignments are processed at this time as well. + # + # `args` is the list of arguments to peruse to get the list of tasks. + # It should be the command line that was given to rake, less any + # recognised command-line options, which OptionParser.parse will + # have taken care of already. + # + # source://rake-13.0.6/lib/rake/application.rb:758 + def collect_command_line_tasks(args); end + + # Default task name ("default"). + # (May be overridden by subclasses) + # + # source://rake-13.0.6/lib/rake/application.rb:772 + def default_task_name; end + + # Warn about deprecated usage. + # + # Example: + # Rake.application.deprecate("import", "Rake.import", caller.first) + # + # source://rake-13.0.6/lib/rake/application.rb:258 + def deprecate(old_usage, new_usage, call_site); end + + # source://rake-13.0.6/lib/rake/application.rb:222 + def display_cause_details(ex); end + + # Display the error message that caused the exception. + # + # source://rake-13.0.6/lib/rake/application.rb:206 + def display_error_message(ex); end + + # source://rake-13.0.6/lib/rake/application.rb:245 + def display_exception_backtrace(ex); end + + # source://rake-13.0.6/lib/rake/application.rb:214 + def display_exception_details(ex); end + + # source://rake-13.0.6/lib/rake/application.rb:229 + def display_exception_details_seen; end + + # source://rake-13.0.6/lib/rake/application.rb:237 + def display_exception_message_details(ex); end + + # Display the tasks and prerequisites + # + # source://rake-13.0.6/lib/rake/application.rb:381 + def display_prerequisites; end + + # Display the tasks and comments. + # + # source://rake-13.0.6/lib/rake/application.rb:298 + def display_tasks_and_comments; end + + # Calculate the dynamic width of the + # + # source://rake-13.0.6/lib/rake/application.rb:349 + def dynamic_width; end + + # source://rake-13.0.6/lib/rake/application.rb:353 + def dynamic_width_stty; end + + # source://rake-13.0.6/lib/rake/application.rb:357 + def dynamic_width_tput; end + + # Exit the program because of an unhandled exception. + # (may be overridden by subclasses) + # + # source://rake-13.0.6/lib/rake/application.rb:201 + def exit_because_of_exception(ex); end + + # source://rake-13.0.6/lib/rake/application.rb:678 + def find_rakefile_location; end + + # Read and handle the command line options. Returns the command line + # arguments that we didn't understand, which should (in theory) be just + # task names and env vars. + # + # source://rake-13.0.6/lib/rake/application.rb:644 + def handle_options(argv); end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:233 + def has_cause?(ex); end + + # True if one of the files in RAKEFILES is in the current directory. + # If a match is found, it is copied into @rakefile. + # + # source://rake-13.0.6/lib/rake/application.rb:274 + def have_rakefile; end + + # Initialize the command line parameters and app name. + # + # source://rake-13.0.6/lib/rake/application.rb:88 + def init(app_name = T.unsafe(nil), argv = T.unsafe(nil)); end + + # Invokes a task with arguments that are extracted from +task_string+ + # + # source://rake-13.0.6/lib/rake/application.rb:157 + def invoke_task(task_string); end + + # Load the pending list of imported files. + # + # source://rake-13.0.6/lib/rake/application.rb:782 + def load_imports; end + + # Find the rakefile and then load it and any pending imports. + # + # source://rake-13.0.6/lib/rake/application.rb:102 + def load_rakefile; end + + # The name of the application (typically 'rake') + # + # source://rake-13.0.6/lib/rake/application.rb:24 + def name; end + + # Application options from the command line + # + # source://rake-13.0.6/lib/rake/application.rb:145 + def options; end + + # The original directory where rake was invoked. + # + # source://rake-13.0.6/lib/rake/application.rb:27 + def original_dir; end + + # source://rake-13.0.6/lib/rake/application.rb:163 + def parse_task_string(string); end + + # source://rake-13.0.6/lib/rake/application.rb:690 + def print_rakefile_directory(location); end + + # Similar to the regular Ruby +require+ command, but will check + # for *.rake files in addition to *.rb files. + # + # source://rake-13.0.6/lib/rake/application.rb:664 + def rake_require(file_name, paths = T.unsafe(nil), loaded = T.unsafe(nil)); end + + # Name of the actual rakefile used. + # + # source://rake-13.0.6/lib/rake/application.rb:30 + def rakefile; end + + # source://rake-13.0.6/lib/rake/application.rb:798 + def rakefile_location(backtrace = T.unsafe(nil)); end + + # source://rake-13.0.6/lib/rake/application.rb:695 + def raw_load_rakefile; end + + # Run the Rake application. The run method performs the following + # three steps: + # + # * Initialize the command line options (+init+). + # * Define the tasks (+load_rakefile+). + # * Run the top level tasks (+top_level+). + # + # If you wish to build a custom rake command, you should call + # +init+ on your application. Then define any tasks. Finally, + # call +top_level+ to run your top level tasks. + # + # source://rake-13.0.6/lib/rake/application.rb:79 + def run(argv = T.unsafe(nil)); end + + # Run the given block with the thread startup and shutdown. + # + # source://rake-13.0.6/lib/rake/application.rb:122 + def run_with_threads; end + + # source://rake-13.0.6/lib/rake/application.rb:807 + def set_default_options; end + + # Provide standard exception handling for the given block. + # + # source://rake-13.0.6/lib/rake/application.rb:185 + def standard_exception_handling; end + + # A list of all the standard options used in rake, suitable for + # passing to OptionParser. + # + # source://rake-13.0.6/lib/rake/application.rb:402 + def standard_rake_options; end + + # The directory path containing the system wide rakefiles. + # + # source://rake-13.0.6/lib/rake/application.rb:727 + def system_dir; end + + # Number of columns on the terminal + # + # source://rake-13.0.6/lib/rake/application.rb:33 + def terminal_columns; end + + # Number of columns on the terminal + # + # source://rake-13.0.6/lib/rake/application.rb:33 + def terminal_columns=(_arg0); end + + # source://rake-13.0.6/lib/rake/application.rb:337 + def terminal_width; end + + # Return the thread pool used for multithreaded processing. + # + # source://rake-13.0.6/lib/rake/application.rb:150 + def thread_pool; end + + # Run the top level tasks of a Rake application. + # + # source://rake-13.0.6/lib/rake/application.rb:109 + def top_level; end + + # List of the top level task names (task names from the command line). + # + # source://rake-13.0.6/lib/rake/application.rb:36 + def top_level_tasks; end + + # source://rake-13.0.6/lib/rake/application.rb:388 + def trace(*strings); end + + # source://rake-13.0.6/lib/rake/application.rb:370 + def truncate(string, width); end + + # We will truncate output if we are outputting to a TTY or if we've been + # given an explicit column width to honor + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:293 + def truncate_output?; end + + # Override the detected TTY output state (mostly for testing) + # + # source://rake-13.0.6/lib/rake/application.rb:39 + def tty_output=(_arg0); end + + # True if we are outputting to TTY, false otherwise + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:287 + def tty_output?; end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:361 + def unix?; end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:366 + def windows?; end + + private + + # source://rake-13.0.6/lib/rake/application.rb:721 + def glob(path, &block); end + + # Does the exception have a task invocation chain? + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/application.rb:267 + def has_chain?(exception); end + + # source://rake-13.0.6/lib/rake/application.rb:620 + def select_tasks_to_show(options, show_tasks, value); end + + # source://rake-13.0.6/lib/rake/application.rb:627 + def select_trace_output(options, trace_option, value); end + + # source://rake-13.0.6/lib/rake/application.rb:393 + def sort_options(options); end + + # source://rake-13.0.6/lib/rake/application.rb:744 + def standard_system_dir; end +end + +# source://rake-13.0.6/lib/rake/application.rb:41 +Rake::Application::DEFAULT_RAKEFILES = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/backtrace.rb:3 +module Rake::Backtrace + class << self + # source://rake-13.0.6/lib/rake/backtrace.rb:18 + def collapse(backtrace); end + end +end + +# source://rake-13.0.6/lib/rake/backtrace.rb:8 +Rake::Backtrace::SUPPRESSED_PATHS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/backtrace.rb:12 +Rake::Backtrace::SUPPRESSED_PATHS_RE = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/backtrace.rb:16 +Rake::Backtrace::SUPPRESS_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rake-13.0.6/lib/rake/backtrace.rb:4 +Rake::Backtrace::SYS_KEYS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/backtrace.rb:5 +Rake::Backtrace::SYS_PATHS = T.let(T.unsafe(nil), Array) + +# Mixin for creating easily cloned objects. +# +# source://rake-13.0.6/lib/rake/cloneable.rb:6 +module Rake::Cloneable + private + + # The hook that is invoked by 'clone' and 'dup' methods. + # + # source://rake-13.0.6/lib/rake/cloneable.rb:8 + def initialize_copy(source); end +end + +# source://rake-13.0.6/lib/rake/application.rb:13 +class Rake::CommandLineOptionError < ::StandardError; end + +# Based on a script at: +# http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed +# +# source://rake-13.0.6/lib/rake/cpu_counter.rb:6 +class Rake::CpuCounter + # source://rake-13.0.6/lib/rake/cpu_counter.rb:22 + def count; end + + # source://rake-13.0.6/lib/rake/cpu_counter.rb:11 + def count_with_default(default = T.unsafe(nil)); end + + class << self + # source://rake-13.0.6/lib/rake/cpu_counter.rb:7 + def count; end + end +end + +# DSL is a module that provides #task, #desc, #namespace, etc. Use this +# when you'd like to use rake outside the top level scope. +# +# For a Rakefile you run from the command line this module is automatically +# included. +# +# source://rake-13.0.6/lib/rake/dsl_definition.rb:14 +module Rake::DSL + include ::FileUtils::StreamUtils_ + include ::FileUtils + include ::Rake::FileUtilsExt + + private + + # Describes the next rake task. Duplicate descriptions are discarded. + # Descriptions are shown with rake -T (up to the first + # sentence) and rake -D (the entire description). + # + # Example: + # desc "Run the Unit Tests" + # task test: [:build] + # # ... run tests + # end + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:165 + def desc(description); end + + # Declare a set of files tasks to create the given directories on + # demand. + # + # Example: + # directory "testdata/doc" + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:92 + def directory(*args, &block); end + + # Declare a file task. + # + # Example: + # file "config.cfg" => ["config.template"] do + # open("config.cfg", "w") do |outfile| + # open("config.template") do |infile| + # while line = infile.gets + # outfile.puts line + # end + # end + # end + # end + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:76 + def file(*args, &block); end + + # Declare a file creation task. + # (Mainly used for the directory command). + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:82 + def file_create(*args, &block); end + + # Import the partial Rakefiles +fn+. Imported files are loaded + # _after_ the current file is completely loaded. This allows the + # import statement to appear anywhere in the importing file, and yet + # allowing the imported files to depend on objects defined in the + # importing file. + # + # A common use of the import statement is to include files + # containing dependency declarations. + # + # See also the --rakelibdir command line option. + # + # Example: + # import ".depend", "my_rules" + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:183 + def import(*fns); end + + # Declare a task that performs its prerequisites in + # parallel. Multitasks does *not* guarantee that its prerequisites + # will execute in any given order (which is obvious when you think + # about it) + # + # Example: + # multitask deploy: %w[deploy_gem deploy_rdoc] + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:112 + def multitask(*args, &block); end + + # Create a new rake namespace and use it for evaluating the given + # block. Returns a NameSpace object that can be used to lookup + # tasks defined in the namespace. + # + # Example: + # + # ns = namespace "nested" do + # # the "nested:run" task + # task :run + # end + # task_run = ns[:run] # find :run in the given namespace. + # + # Tasks can also be defined in a namespace by using a ":" in the task + # name: + # + # task "nested:test" do + # # ... + # end + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:135 + def namespace(name = T.unsafe(nil), &block); end + + # Declare a rule for auto-tasks. + # + # Example: + # rule '.o' => '.c' do |t| + # sh 'cc', '-o', t.name, t.source + # end + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:151 + def rule(*args, &block); end + + # :call-seq: + # task(task_name) + # task(task_name: dependencies) + # task(task_name, arguments => dependencies) + # + # Declare a basic task. The +task_name+ is always the first argument. If + # the task name contains a ":" it is defined in that namespace. + # + # The +dependencies+ may be a single task name or an Array of task names. + # The +argument+ (a single name) or +arguments+ (an Array of names) define + # the arguments provided to the task. + # + # The task, argument and dependency names may be either symbols or + # strings. + # + # A task with a single dependency: + # + # task clobber: %w[clean] do + # rm_rf "html" + # end + # + # A task with an argument and a dependency: + # + # task :package, [:version] => :test do |t, args| + # # ... + # end + # + # To invoke this task from the command line: + # + # $ rake package[1.2.3] + # + # source://rake-13.0.6/lib/rake/dsl_definition.rb:59 + def task(*args, &block); end +end + +# Default Rakefile loader used by +import+. +# +# source://rake-13.0.6/lib/rake/default_loader.rb:5 +class Rake::DefaultLoader + # Loads a rakefile into the current application from +fn+ + # + # source://rake-13.0.6/lib/rake/default_loader.rb:10 + def load(fn); end +end + +# source://rake-13.0.6/lib/rake/early_time.rb:21 +Rake::EARLY = T.let(T.unsafe(nil), Rake::EarlyTime) + +# source://rake-13.0.6/lib/rake/task_arguments.rb:108 +Rake::EMPTY_TASK_ARGS = T.let(T.unsafe(nil), Rake::TaskArguments) + +# EarlyTime is a fake timestamp that occurs _before_ any other time value. +# +# source://rake-13.0.6/lib/rake/early_time.rb:5 +class Rake::EarlyTime + include ::Comparable + include ::Singleton + extend ::Singleton::SingletonClassMethods + + # The EarlyTime always comes before +other+! + # + # source://rake-13.0.6/lib/rake/early_time.rb:12 + def <=>(other); end + + # source://rake-13.0.6/lib/rake/early_time.rb:16 + def to_s; end +end + +# A FileCreationTask is a file task that when used as a dependency will be +# needed if and only if the file has not been created. Once created, it is +# not re-triggered if any of its dependencies are newer, nor does trigger +# any rebuilds of tasks that depend on it whenever it is updated. +# +# source://rake-13.0.6/lib/rake/file_creation_task.rb:13 +class Rake::FileCreationTask < ::Rake::FileTask + # Is this file task needed? Yes if it doesn't exist. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_creation_task.rb:14 + def needed?; end + + # Time stamp for file creation task. This time stamp is earlier + # than any other time stamp. + # + # source://rake-13.0.6/lib/rake/file_creation_task.rb:20 + def timestamp; end +end + +# A FileList is essentially an array with a few helper methods defined to +# make file manipulation a bit easier. +# +# FileLists are lazy. When given a list of glob patterns for possible files +# to be included in the file list, instead of searching the file structures +# to find the files, a FileList holds the pattern for latter use. +# +# This allows us to define a number of FileList to match any number of +# files, but only search out the actual files when then FileList itself is +# actually used. The key is that the first time an element of the +# FileList/Array is requested, the pending patterns are resolved into a real +# list of file names. +# +# source://rake-13.0.6/lib/rake/file_list.rb:22 +class Rake::FileList + include ::Rake::Cloneable + + # Create a file list from the globbable patterns given. If you wish to + # perform multiple includes or excludes at object build time, use the + # "yield self" pattern. + # + # Example: + # file_list = FileList.new('lib/**/*.rb', 'test/test*.rb') + # + # pkg_files = FileList.new('lib/**/*') do |fl| + # fl.exclude(/\bCVS\b/) + # end + # + # @return [FileList] a new instance of FileList + # @yield [_self] + # @yieldparam _self [Rake::FileList] the object that the method was called on + # + # source://rake-13.0.6/lib/rake/file_list.rb:99 + def initialize(*patterns); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def &(*args, &block); end + + # Redefine * to return either a string or a new file list. + # + # source://rake-13.0.6/lib/rake/file_list.rb:193 + def *(other); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def +(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def -(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:203 + def <<(obj); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def <=>(*args, &block); end + + # A FileList is equal through array equality. + # + # source://rake-13.0.6/lib/rake/file_list.rb:171 + def ==(array); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def [](*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def []=(*args, &block); end + + # Add file names defined by glob patterns to the file list. If an array + # is given, add each element of the array. + # + # Example: + # file_list.include("*.java", "*.cfg") + # file_list.include %w( math.c lib.h *.o ) + # + # source://rake-13.0.6/lib/rake/file_list.rb:116 + def add(*filenames); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def all?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def any?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def append(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def assoc(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def at(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def bsearch(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def bsearch_index(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def chain(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def chunk(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def chunk_while(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def clear(*args, &block); end + + # Clear all the exclude patterns so that we exclude nothing. + # + # source://rake-13.0.6/lib/rake/file_list.rb:164 + def clear_exclude; end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def collect(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def collect!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def collect_concat(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def combination(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def compact(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def compact!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def concat(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def count(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def cycle(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def deconstruct(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def delete(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def delete_at(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def delete_if(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def detect(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def difference(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def dig(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def drop(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def drop_while(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_cons(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_entry(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_index(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_slice(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_with_index(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def each_with_object(*args, &block); end + + # Grep each of the files in the filelist using the given pattern. If a + # block is given, call the block on each matching line, passing the file + # name, line number, and the matching line of text. If no block is given, + # a standard emacs style file:linenumber:line message will be printed to + # standard out. Returns the number of matched items. + # + # source://rake-13.0.6/lib/rake/file_list.rb:293 + def egrep(pattern, *options); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def empty?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def entries(*args, &block); end + + # Register a list of file name patterns that should be excluded from the + # list. Patterns may be regular expressions, glob patterns or regular + # strings. In addition, a block given to exclude will remove entries that + # return true when given to the block. + # + # Note that glob patterns are expanded against the file system. If a file + # is explicitly added to a file list, but does not exist in the file + # system, then an glob pattern in the exclude list will not exclude the + # file. + # + # Examples: + # FileList['a.c', 'b.c'].exclude("a.c") => ['b.c'] + # FileList['a.c', 'b.c'].exclude(/^a/) => ['b.c'] + # + # If "a.c" is a file, then ... + # FileList['a.c', 'b.c'].exclude("a.*") => ['b.c'] + # + # If "a.c" is not a file, then ... + # FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c'] + # + # source://rake-13.0.6/lib/rake/file_list.rb:150 + def exclude(*patterns, &block); end + + # Should the given file name be excluded from the list? + # + # NOTE: This method was formerly named "exclude?", but Rails + # introduced an exclude? method as an array method and setup a + # conflict with file list. We renamed the method to avoid + # confusion. If you were using "FileList#exclude?" in your user + # code, you will need to update. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_list.rb:364 + def excluded_from_list?(fn); end + + # Return a new file list that only contains file names from the current + # file list that exist on the file system. + # + # source://rake-13.0.6/lib/rake/file_list.rb:320 + def existing; end + + # Modify the current file list so that it contains only file name that + # exist on the file system. + # + # source://rake-13.0.6/lib/rake/file_list.rb:326 + def existing!; end + + # Return a new FileList with String#ext method applied to + # each member of the array. + # + # This method is a shortcut for: + # + # array.collect { |item| item.ext(newext) } + # + # +ext+ is a user added method for the Array class. + # + # source://rake-13.0.6/lib/rake/file_list.rb:284 + def ext(newext = T.unsafe(nil)); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def fetch(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def fill(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def filter(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def filter!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def filter_map(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def find(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def find_all(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def find_index(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def first(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def flat_map(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def flatten(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def flatten!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def grep(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def grep_v(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def group_by(*args, &block); end + + # Return a new FileList with the results of running +gsub+ against each + # element of the original list. + # + # Example: + # FileList['lib/test/file', 'x/y'].gsub(/\//, "\\") + # => ['lib\\test\\file', 'x\\y'] + # + # source://rake-13.0.6/lib/rake/file_list.rb:253 + def gsub(pat, rep); end + + # Same as +gsub+ except that the original file list is modified. + # + # source://rake-13.0.6/lib/rake/file_list.rb:264 + def gsub!(pat, rep); end + + # source://rake-13.0.6/lib/rake/file_list.rb:391 + def import(array); end + + # Add file names defined by glob patterns to the file list. If an array + # is given, add each element of the array. + # + # Example: + # file_list.include("*.java", "*.cfg") + # file_list.include %w( math.c lib.h *.o ) + # + # source://rake-13.0.6/lib/rake/file_list.rb:116 + def include(*filenames); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def include?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def index(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def inject(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def insert(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def inspect(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def intersection(*args, &block); end + + # Lie about our class. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_list.rb:187 + def is_a?(klass); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def join(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def keep_if(*args, &block); end + + # Lie about our class. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_list.rb:187 + def kind_of?(klass); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def last(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def lazy(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def length(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def map(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def map!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def max(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def max_by(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def member?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def min(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def min_by(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def minmax(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def minmax_by(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def none?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def one?(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def pack(*args, &block); end + + # FileList version of partition. Needed because the nested arrays should + # be FileLists in this version. + # + # source://rake-13.0.6/lib/rake/file_list.rb:334 + def partition(&block); end + + # Apply the pathmap spec to each of the included file names, returning a + # new file list with the modified paths. (See String#pathmap for + # details.) + # + # source://rake-13.0.6/lib/rake/file_list.rb:272 + def pathmap(spec = T.unsafe(nil), &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def permutation(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def place(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def pop(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def prepend(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def product(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def push(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def rassoc(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def reduce(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def reject(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def reject!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def repeated_combination(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def repeated_permutation(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def replace(*args, &block); end + + # Resolve all the pending adds now. + # + # source://rake-13.0.6/lib/rake/file_list.rb:210 + def resolve; end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def reverse(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def reverse!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def reverse_each(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def rindex(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def rotate(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def rotate!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def sample(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def select(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def select!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def shelljoin(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def shift(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def shuffle(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def shuffle!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def size(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def slice(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def slice!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def slice_after(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def slice_before(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def slice_when(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def sort(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def sort!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def sort_by(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def sort_by!(*args, &block); end + + # Return a new FileList with the results of running +sub+ against each + # element of the original list. + # + # Example: + # FileList['a.c', 'b.c'].sub(/\.c$/, '.o') => ['a.o', 'b.o'] + # + # source://rake-13.0.6/lib/rake/file_list.rb:242 + def sub(pat, rep); end + + # Same as +sub+ except that the original file list is modified. + # + # source://rake-13.0.6/lib/rake/file_list.rb:258 + def sub!(pat, rep); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def sum(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def take(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def take_while(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def tally(*args, &block); end + + # Return the internal array object. + # + # source://rake-13.0.6/lib/rake/file_list.rb:176 + def to_a; end + + # Return the internal array object. + # + # source://rake-13.0.6/lib/rake/file_list.rb:182 + def to_ary; end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def to_h(*args, &block); end + + # Convert a FileList to a string by joining all elements with a space. + # + # source://rake-13.0.6/lib/rake/file_list.rb:344 + def to_s; end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def to_set(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def transpose(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def union(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def uniq(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def uniq!(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def unshift(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def values_at(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:77 + def zip(*args, &block); end + + # source://rake-13.0.6/lib/rake/file_list.rb:68 + def |(*args, &block); end + + private + + # Add matching glob patterns. + # + # source://rake-13.0.6/lib/rake/file_list.rb:350 + def add_matching(pattern); end + + # source://rake-13.0.6/lib/rake/file_list.rb:220 + def resolve_add(fn); end + + # source://rake-13.0.6/lib/rake/file_list.rb:230 + def resolve_exclude; end + + class << self + # Create a new file list including the files listed. Similar to: + # + # FileList.new(*args) + # + # source://rake-13.0.6/lib/rake/file_list.rb:400 + def [](*args); end + + # Get a sorted list of files matching the pattern. This method + # should be preferred to Dir[pattern] and Dir.glob(pattern) because + # the files returned are guaranteed to be sorted. + # + # source://rake-13.0.6/lib/rake/file_list.rb:407 + def glob(pattern, *args); end + end +end + +# List of array methods (that are not in +Object+) that need to be +# delegated. +# +# source://rake-13.0.6/lib/rake/file_list.rb:44 +Rake::FileList::ARRAY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/file_list.rb:381 +Rake::FileList::DEFAULT_IGNORE_PATTERNS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/file_list.rb:387 +Rake::FileList::DEFAULT_IGNORE_PROCS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/file_list.rb:61 +Rake::FileList::DELEGATING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/file_list.rb:86 +Rake::FileList::GLOB_PATTERN = T.let(T.unsafe(nil), Regexp) + +# List of additional methods that must be delegated. +# +# source://rake-13.0.6/lib/rake/file_list.rb:47 +Rake::FileList::MUST_DEFINE = T.let(T.unsafe(nil), Array) + +# List of methods that should not be delegated here (we define special +# versions of them explicitly below). +# +# source://rake-13.0.6/lib/rake/file_list.rb:51 +Rake::FileList::MUST_NOT_DEFINE = T.let(T.unsafe(nil), Array) + +# List of delegated methods that return new array values which need +# wrapping. +# +# source://rake-13.0.6/lib/rake/file_list.rb:55 +Rake::FileList::SPECIAL_RETURN = T.let(T.unsafe(nil), Array) + +# A FileTask is a task that includes time based dependencies. If any of a +# FileTask's prerequisites have a timestamp that is later than the file +# represented by this task, then the file must be rebuilt (using the +# supplied actions). +# +# source://rake-13.0.6/lib/rake/file_task.rb:12 +class Rake::FileTask < ::Rake::Task + # Is this file task needed? Yes if it doesn't exist, or if its time stamp + # is out of date. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_task.rb:16 + def needed?; end + + # Time stamp for file task. + # + # source://rake-13.0.6/lib/rake/file_task.rb:21 + def timestamp; end + + private + + # Are there any prerequisites with a later time than the given time stamp? + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/file_task.rb:32 + def out_of_date?(stamp); end + + class << self + # Apply the scope to the task name according to the rules for this kind + # of task. File based tasks ignore the scope when creating the name. + # + # source://rake-13.0.6/lib/rake/file_task.rb:49 + def scope_name(scope, task_name); end + end +end + +# FileUtilsExt provides a custom version of the FileUtils methods +# that respond to the verbose and nowrite +# commands. +# +# source://rake-13.0.6/lib/rake/file_utils_ext.rb:10 +module Rake::FileUtilsExt + include ::FileUtils::StreamUtils_ + include ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils + extend ::Rake::FileUtilsExt + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def cd(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def chdir(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def chmod(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def chmod_R(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def chown(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def chown_R(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def copy(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def cp(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def cp_lr(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def cp_r(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def install(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def link(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def ln(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def ln_s(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def ln_sf(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def makedirs(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def mkdir(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def mkdir_p(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def mkpath(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def move(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def mv(*args, **options, &block); end + + # Get/set the nowrite flag controlling output from the FileUtils + # utilities. If verbose is true, then the utility method is + # echoed to standard output. + # + # Examples: + # nowrite # return the current value of the + # # nowrite flag + # nowrite(v) # set the nowrite flag to _v_. + # nowrite(v) { code } # Execute code with the nowrite flag set + # # temporarily to _v_. Return to the + # # original value when code is done. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:77 + def nowrite(value = T.unsafe(nil)); end + + # Check that the options do not contain options not listed in + # +optdecl+. An ArgumentError exception is thrown if non-declared + # options are found. + # + # @raise [ArgumentError] + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:123 + def rake_check_options(options, *optdecl); end + + # Send the message to the default rake output (which is $stderr). + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:116 + def rake_output_message(message); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def remove(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rm(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rm_f(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rm_r(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rm_rf(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rmdir(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def rmtree(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def safe_unlink(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def symlink(*args, **options, &block); end + + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:34 + def touch(*args, **options, &block); end + + # Get/set the verbose flag controlling output from the FileUtils + # utilities. If verbose is true, then the utility method is + # echoed to standard output. + # + # Examples: + # verbose # return the current value of the + # # verbose flag + # verbose(v) # set the verbose flag to _v_. + # verbose(v) { code } # Execute code with the verbose flag set + # # temporarily to _v_. Return to the + # # original value when code is done. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:53 + def verbose(value = T.unsafe(nil)); end + + # Use this function to prevent potentially destructive ruby code + # from running when the :nowrite flag is set. + # + # Example: + # + # when_writing("Building Project") do + # project.build + # end + # + # The following code will build the project under normal + # conditions. If the nowrite(true) flag is set, then the example + # will print: + # + # DRYRUN: Building Project + # + # instead of actually building the project. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:107 + def when_writing(msg = T.unsafe(nil)); end + + class << self + # Returns the value of attribute nowrite_flag. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:14 + def nowrite_flag; end + + # Sets the attribute nowrite_flag + # + # @param value the value to set the attribute nowrite_flag to. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:14 + def nowrite_flag=(_arg0); end + + # Returns the value of attribute verbose_flag. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:14 + def verbose_flag; end + + # Sets the attribute verbose_flag + # + # @param value the value to set the attribute verbose_flag to. + # + # source://rake-13.0.6/lib/rake/file_utils_ext.rb:14 + def verbose_flag=(_arg0); end + end +end + +# source://rake-13.0.6/lib/rake/file_utils_ext.rb:17 +Rake::FileUtilsExt::DEFAULT = T.let(T.unsafe(nil), Object) + +# InvocationChain tracks the chain of task invocations to detect +# circular dependencies. +# +# source://rake-13.0.6/lib/rake/invocation_chain.rb:6 +class Rake::InvocationChain < ::Rake::LinkedList + # Append an invocation to the chain of invocations. It is an error + # if the invocation already listed. + # + # source://rake-13.0.6/lib/rake/invocation_chain.rb:15 + def append(invocation); end + + # Is the invocation already in the chain? + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/invocation_chain.rb:9 + def member?(invocation); end + + # Convert to string, ie: TOP => invocation => invocation + # + # source://rake-13.0.6/lib/rake/invocation_chain.rb:23 + def to_s; end + + private + + # source://rake-13.0.6/lib/rake/invocation_chain.rb:34 + def prefix; end + + class << self + # Class level append. + # + # source://rake-13.0.6/lib/rake/invocation_chain.rb:28 + def append(invocation, chain); end + end +end + +# source://rake-13.0.6/lib/rake/invocation_chain.rb:55 +Rake::InvocationChain::EMPTY = T.let(T.unsafe(nil), Rake::InvocationChain::EmptyInvocationChain) + +# Null object for an empty chain. +# +# source://rake-13.0.6/lib/rake/invocation_chain.rb:39 +class Rake::InvocationChain::EmptyInvocationChain < ::Rake::LinkedList::EmptyLinkedList + # source://rake-13.0.6/lib/rake/invocation_chain.rb:46 + def append(invocation); end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/invocation_chain.rb:42 + def member?(obj); end + + # source://rake-13.0.6/lib/rake/invocation_chain.rb:50 + def to_s; end +end + +# source://rake-13.0.6/lib/rake/invocation_exception_mixin.rb:3 +module Rake::InvocationExceptionMixin + # Return the invocation chain (list of Rake tasks) that were in + # effect when this exception was detected by rake. May be null if + # no tasks were active. + # + # source://rake-13.0.6/lib/rake/invocation_exception_mixin.rb:7 + def chain; end + + # Set the invocation chain in effect when this exception was + # detected. + # + # source://rake-13.0.6/lib/rake/invocation_exception_mixin.rb:13 + def chain=(value); end +end + +# source://rake-13.0.6/lib/rake/late_time.rb:17 +Rake::LATE = T.let(T.unsafe(nil), Rake::LateTime) + +# LateTime is a fake timestamp that occurs _after_ any other time value. +# +# source://rake-13.0.6/lib/rake/late_time.rb:4 +class Rake::LateTime + include ::Comparable + include ::Singleton + extend ::Singleton::SingletonClassMethods + + # source://rake-13.0.6/lib/rake/late_time.rb:8 + def <=>(other); end + + # source://rake-13.0.6/lib/rake/late_time.rb:12 + def to_s; end +end + +# Polylithic linked list structure used to implement several data +# structures in Rake. +# +# source://rake-13.0.6/lib/rake/linked_list.rb:6 +class Rake::LinkedList + include ::Enumerable + + # @return [LinkedList] a new instance of LinkedList + # + # source://rake-13.0.6/lib/rake/linked_list.rb:84 + def initialize(head, tail = T.unsafe(nil)); end + + # Lists are structurally equivalent. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:25 + def ==(other); end + + # Polymorphically add a new element to the head of a list. The + # type of head node will be the same list type as the tail. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:12 + def conj(item); end + + # For each item in the list. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:48 + def each; end + + # Is the list empty? + # .make guards against a list being empty making any instantiated LinkedList + # object not empty by default + # You should consider overriding this method if you implement your own .make method + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/linked_list.rb:20 + def empty?; end + + # Returns the value of attribute head. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:8 + def head; end + + # Same as +to_s+, but with inspected items. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:42 + def inspect; end + + # Returns the value of attribute tail. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:8 + def tail; end + + # Convert to string: LL(item, item...) + # + # source://rake-13.0.6/lib/rake/linked_list.rb:36 + def to_s; end + + class << self + # Cons a new head onto the tail list. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:73 + def cons(head, tail); end + + # The standard empty list class for the given LinkedList class. + # + # source://rake-13.0.6/lib/rake/linked_list.rb:78 + def empty; end + + # Make a list out of the given arguments. This method is + # polymorphic + # + # source://rake-13.0.6/lib/rake/linked_list.rb:59 + def make(*args); end + end +end + +# source://rake-13.0.6/lib/rake/linked_list.rb:110 +Rake::LinkedList::EMPTY = T.let(T.unsafe(nil), Rake::LinkedList::EmptyLinkedList) + +# Represent an empty list, using the Null Object Pattern. +# +# When inheriting from the LinkedList class, you should implement +# a type specific Empty class as well. Make sure you set the class +# instance variable @parent to the associated list class (this +# allows conj, cons and make to work polymorphically). +# +# source://rake-13.0.6/lib/rake/linked_list.rb:95 +class Rake::LinkedList::EmptyLinkedList < ::Rake::LinkedList + # @return [EmptyLinkedList] a new instance of EmptyLinkedList + # + # source://rake-13.0.6/lib/rake/linked_list.rb:98 + def initialize; end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/linked_list.rb:101 + def empty?; end + + class << self + # source://rake-13.0.6/lib/rake/linked_list.rb:105 + def cons(head, tail); end + end +end + +# Same as a regular task, but the immediate prerequisites are done in +# parallel using Ruby threads. +# +# source://rake-13.0.6/lib/rake/multi_task.rb:7 +class Rake::MultiTask < ::Rake::Task + private + + # source://rake-13.0.6/lib/rake/multi_task.rb:10 + def invoke_prerequisites(task_args, invocation_chain); end +end + +# The NameSpace class will lookup task names in the scope defined by a +# +namespace+ command. +# +# source://rake-13.0.6/lib/rake/name_space.rb:6 +class Rake::NameSpace + # Create a namespace lookup object using the given task manager + # and the list of scopes. + # + # @return [NameSpace] a new instance of NameSpace + # + # source://rake-13.0.6/lib/rake/name_space.rb:12 + def initialize(task_manager, scope_list); end + + # Lookup a task named +name+ in the namespace. + # + # source://rake-13.0.6/lib/rake/name_space.rb:20 + def [](name); end + + # The scope of the namespace (a LinkedList) + # + # source://rake-13.0.6/lib/rake/name_space.rb:27 + def scope; end + + # Return the list of tasks defined in this and nested namespaces. + # + # source://rake-13.0.6/lib/rake/name_space.rb:34 + def tasks; end +end + +# Include PrivateReader to use +private_reader+. +# +# source://rake-13.0.6/lib/rake/private_reader.rb:5 +module Rake::PrivateReader + mixes_in_class_methods ::Rake::PrivateReader::ClassMethods + + class << self + # source://rake-13.0.6/lib/rake/private_reader.rb:7 + def included(base); end + end +end + +# source://rake-13.0.6/lib/rake/private_reader.rb:11 +module Rake::PrivateReader::ClassMethods + # Declare a list of private accessors + # + # source://rake-13.0.6/lib/rake/private_reader.rb:14 + def private_reader(*names); end +end + +# A Promise object represents a promise to do work (a chore) in the +# future. The promise is created with a block and a list of +# arguments for the block. Calling value will return the value of +# the promised chore. +# +# Used by ThreadPool. +# +# source://rake-13.0.6/lib/rake/promise.rb:11 +class Rake::Promise + # Create a promise to do the chore specified by the block. + # + # @return [Promise] a new instance of Promise + # + # source://rake-13.0.6/lib/rake/promise.rb:17 + def initialize(args, &block); end + + # source://rake-13.0.6/lib/rake/promise.rb:14 + def recorder; end + + # source://rake-13.0.6/lib/rake/promise.rb:14 + def recorder=(_arg0); end + + # Return the value of this promise. + # + # If the promised chore is not yet complete, then do the work + # synchronously. We will wait. + # + # source://rake-13.0.6/lib/rake/promise.rb:29 + def value; end + + # If no one else is working this promise, go ahead and do the chore. + # + # source://rake-13.0.6/lib/rake/promise.rb:42 + def work; end + + private + + # Perform the chore promised + # + # source://rake-13.0.6/lib/rake/promise.rb:57 + def chore; end + + # Are we done with the promise + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/promise.rb:83 + def complete?; end + + # free up these items for the GC + # + # source://rake-13.0.6/lib/rake/promise.rb:88 + def discard; end + + # Did the promise throw an error + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/promise.rb:78 + def error?; end + + # Do we have a result for the promise + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/promise.rb:73 + def result?; end + + # Record execution statistics if there is a recorder + # + # source://rake-13.0.6/lib/rake/promise.rb:94 + def stat(*args); end +end + +# source://rake-13.0.6/lib/rake/promise.rb:12 +Rake::Promise::NOT_SET = T.let(T.unsafe(nil), Object) + +# Exit status class for times the system just gives us a nil. +# +# source://rake-13.0.6/lib/rake/pseudo_status.rb:6 +class Rake::PseudoStatus + # @return [PseudoStatus] a new instance of PseudoStatus + # + # source://rake-13.0.6/lib/rake/pseudo_status.rb:9 + def initialize(code = T.unsafe(nil)); end + + # source://rake-13.0.6/lib/rake/pseudo_status.rb:17 + def >>(n); end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/pseudo_status.rb:25 + def exited?; end + + # source://rake-13.0.6/lib/rake/pseudo_status.rb:7 + def exitstatus; end + + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/pseudo_status.rb:21 + def stopped?; end + + # source://rake-13.0.6/lib/rake/pseudo_status.rb:13 + def to_i; end +end + +# source://RUBY_ROOT/rdoc/task.rb:326 +Rake::RDocTask = RDoc::Task + +# Error indicating a recursion overflow error in task selection. +# +# source://rake-13.0.6/lib/rake/rule_recursion_overflow_error.rb:5 +class Rake::RuleRecursionOverflowError < ::StandardError + # @return [RuleRecursionOverflowError] a new instance of RuleRecursionOverflowError + # + # source://rake-13.0.6/lib/rake/rule_recursion_overflow_error.rb:6 + def initialize(*args); end + + # source://rake-13.0.6/lib/rake/rule_recursion_overflow_error.rb:11 + def add_target(target); end + + # source://rake-13.0.6/lib/rake/rule_recursion_overflow_error.rb:15 + def message; end +end + +# source://rake-13.0.6/lib/rake/scope.rb:3 +class Rake::Scope < ::Rake::LinkedList + # Path for the scope. + # + # source://rake-13.0.6/lib/rake/scope.rb:6 + def path; end + + # Path for the scope + the named path. + # + # source://rake-13.0.6/lib/rake/scope.rb:11 + def path_with_task_name(task_name); end + + # Trim +n+ innermost scope levels from the scope. In no case will + # this trim beyond the toplevel scope. + # + # source://rake-13.0.6/lib/rake/scope.rb:17 + def trim(n); end +end + +# Singleton null object for an empty scope. +# +# source://rake-13.0.6/lib/rake/scope.rb:41 +Rake::Scope::EMPTY = T.let(T.unsafe(nil), Rake::Scope::EmptyScope) + +# Scope lists always end with an EmptyScope object. See Null +# Object Pattern) +# +# source://rake-13.0.6/lib/rake/scope.rb:28 +class Rake::Scope::EmptyScope < ::Rake::LinkedList::EmptyLinkedList + # source://rake-13.0.6/lib/rake/scope.rb:31 + def path; end + + # source://rake-13.0.6/lib/rake/scope.rb:35 + def path_with_task_name(task_name); end +end + +# A Task is the basic unit of work in a Rakefile. Tasks have associated +# actions (possibly more than one) and a list of prerequisites. When +# invoked, a task will first ensure that all of its prerequisites have an +# opportunity to run and then it will execute its own actions. +# +# Tasks are not usually created directly using the new method, but rather +# use the +file+ and +task+ convenience methods. +# +# source://rake-13.0.6/lib/rake/task.rb:15 +class Rake::Task + # Create a task named +task_name+ with no actions or prerequisites. Use + # +enhance+ to add actions and prerequisites. + # + # @return [Task] a new instance of Task + # + # source://rake-13.0.6/lib/rake/task.rb:99 + def initialize(task_name, app); end + + # List of actions attached to a task. + # + # source://rake-13.0.6/lib/rake/task.rb:24 + def actions; end + + # Add a description to the task. The description can consist of an option + # argument list (enclosed brackets) and an optional comment. + # + # source://rake-13.0.6/lib/rake/task.rb:298 + def add_description(description); end + + # List of all unique prerequisite tasks including prerequisite tasks' + # prerequisites. + # Includes self when cyclic dependencies are found. + # + # source://rake-13.0.6/lib/rake/task.rb:77 + def all_prerequisite_tasks; end + + # Has this task already been invoked? Already invoked tasks + # will be skipped unless you reenable them. + # + # source://rake-13.0.6/lib/rake/task.rb:39 + def already_invoked; end + + # Application owning this task. + # + # source://rake-13.0.6/lib/rake/task.rb:27 + def application; end + + # Application owning this task. + # + # source://rake-13.0.6/lib/rake/task.rb:27 + def application=(_arg0); end + + # Argument description (nil if none). + # + # source://rake-13.0.6/lib/rake/task.rb:136 + def arg_description; end + + # Name of arguments for this task. + # + # source://rake-13.0.6/lib/rake/task.rb:141 + def arg_names; end + + # Clear the existing prerequisites, actions, comments, and arguments of a rake task. + # + # source://rake-13.0.6/lib/rake/task.rb:153 + def clear; end + + # Clear the existing actions on a rake task. + # + # source://rake-13.0.6/lib/rake/task.rb:168 + def clear_actions; end + + # Clear the existing arguments on a rake task. + # + # source://rake-13.0.6/lib/rake/task.rb:180 + def clear_args; end + + # Clear the existing comments on a rake task. + # + # source://rake-13.0.6/lib/rake/task.rb:174 + def clear_comments; end + + # Clear the existing prerequisites of a rake task. + # + # source://rake-13.0.6/lib/rake/task.rb:162 + def clear_prerequisites; end + + # First line (or sentence) of all comments. Multiple comments are + # separated by a "/". + # + # source://rake-13.0.6/lib/rake/task.rb:322 + def comment; end + + # source://rake-13.0.6/lib/rake/task.rb:304 + def comment=(comment); end + + # Enhance a task with prerequisites or actions. Returns self. + # + # source://rake-13.0.6/lib/rake/task.rb:115 + def enhance(deps = T.unsafe(nil), &block); end + + # Execute the actions associated with this task. + # + # source://rake-13.0.6/lib/rake/task.rb:270 + def execute(args = T.unsafe(nil)); end + + # Full collection of comments. Multiple comments are separated by + # newlines. + # + # source://rake-13.0.6/lib/rake/task.rb:316 + def full_comment; end + + # source://rake-13.0.6/lib/rake/task.rb:46 + def inspect; end + + # Return a string describing the internal state of a task. Useful for + # debugging. + # + # source://rake-13.0.6/lib/rake/task.rb:354 + def investigation; end + + # Invoke the task if it is needed. Prerequisites are invoked first. + # + # source://rake-13.0.6/lib/rake/task.rb:186 + def invoke(*args); end + + # Invoke all the prerequisites of a task. + # + # source://rake-13.0.6/lib/rake/task.rb:237 + def invoke_prerequisites(task_args, invocation_chain); end + + # Invoke all the prerequisites of a task in parallel. + # + # source://rake-13.0.6/lib/rake/task.rb:249 + def invoke_prerequisites_concurrently(task_args, invocation_chain); end + + # File/Line locations of each of the task definitions for this + # task (only valid if the task was defined with the detect + # location option set). + # + # source://rake-13.0.6/lib/rake/task.rb:35 + def locations; end + + # Name of the task, including any namespace qualifiers. + # + # source://rake-13.0.6/lib/rake/task.rb:122 + def name; end + + # Name of task with argument list description. + # + # source://rake-13.0.6/lib/rake/task.rb:127 + def name_with_args; end + + # Is this task needed? + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/task.rb:286 + def needed?; end + + # List of order only prerequisites for a task. + # + # source://rake-13.0.6/lib/rake/task.rb:21 + def order_only_prerequisites; end + + # List of prerequisites for a task. + # + # source://rake-13.0.6/lib/rake/task.rb:17 + def prereqs; end + + # List of prerequisite tasks + # + # source://rake-13.0.6/lib/rake/task.rb:61 + def prerequisite_tasks; end + + # List of prerequisites for a task. + # + # source://rake-13.0.6/lib/rake/task.rb:17 + def prerequisites; end + + # Reenable the task, allowing its tasks to be executed if the task + # is invoked again. + # + # source://rake-13.0.6/lib/rake/task.rb:147 + def reenable; end + + # Array of nested namespaces names used for task lookup by this task. + # + # source://rake-13.0.6/lib/rake/task.rb:30 + def scope; end + + # Set the names of the arguments for this task. +args+ should be + # an array of symbols, one for each argument name. + # + # source://rake-13.0.6/lib/rake/task.rb:348 + def set_arg_names(args); end + + # First source from a rule (nil if no sources) + # + # source://rake-13.0.6/lib/rake/task.rb:93 + def source; end + + # source://rake-13.0.6/lib/rake/task.rb:52 + def sources; end + + # List of sources for task. + # + # source://rake-13.0.6/lib/rake/task.rb:51 + def sources=(_arg0); end + + # Timestamp for this task. Basic tasks return the current time for their + # time stamp. Other tasks can be more sophisticated. + # + # source://rake-13.0.6/lib/rake/task.rb:292 + def timestamp; end + + # Return task name + # + # source://rake-13.0.6/lib/rake/task.rb:42 + def to_s; end + + # Add order only dependencies. + # + # source://rake-13.0.6/lib/rake/task.rb:379 + def |(deps); end + + protected + + # source://rake-13.0.6/lib/rake/task.rb:83 + def collect_prerequisites(seen); end + + # Same as invoke, but explicitly pass a call chain to detect + # circular dependencies. + # + # If multiple tasks depend on this + # one in parallel, they will all fail if the first execution of + # this task fails. + # + # source://rake-13.0.6/lib/rake/task.rb:197 + def invoke_with_call_chain(task_args, invocation_chain); end + + private + + # source://rake-13.0.6/lib/rake/task.rb:229 + def add_chain_to(exception, new_chain); end + + # source://rake-13.0.6/lib/rake/task.rb:308 + def add_comment(comment); end + + # Get the first sentence in a string. The sentence is terminated + # by the first period, exclamation mark, or the end of the line. + # Decimal points do not count as periods. + # + # source://rake-13.0.6/lib/rake/task.rb:341 + def first_sentence(string); end + + # Format the trace flags for display. + # + # source://rake-13.0.6/lib/rake/task.rb:261 + def format_trace_flags; end + + # source://rake-13.0.6/lib/rake/task.rb:65 + def lookup_prerequisite(prerequisite_name); end + + # Transform the list of comments as specified by the block and + # join with the separator. + # + # source://rake-13.0.6/lib/rake/task.rb:328 + def transform_comments(separator, &block); end + + class << self + # Return a task with the given name. If the task is not currently + # known, try to synthesize one from the defined rules. If no rules are + # found, but an existing file matches the task name, assume it is a file + # task with no dependencies or actions. + # + # source://rake-13.0.6/lib/rake/task.rb:404 + def [](task_name); end + + # Clear the task list. This cause rake to immediately forget all the + # tasks that have been assigned. (Normally used in the unit tests.) + # + # source://rake-13.0.6/lib/rake/task.rb:391 + def clear; end + + # Define a rule for synthesizing tasks. + # + # source://rake-13.0.6/lib/rake/task.rb:421 + def create_rule(*args, &block); end + + # Define a task given +args+ and an option block. If a rule with the + # given name already exists, the prerequisites and actions are added to + # the existing task. Returns the defined task. + # + # source://rake-13.0.6/lib/rake/task.rb:416 + def define_task(*args, &block); end + + # Format dependencies parameter to pass to task. + # + # source://rake-13.0.6/lib/rake/task.rb:373 + def format_deps(deps); end + + # Apply the scope to the task name according to the rules for + # this kind of task. Generic tasks will accept the scope as + # part of the name. + # + # source://rake-13.0.6/lib/rake/task.rb:428 + def scope_name(scope, task_name); end + + # TRUE if the task name is already defined. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/task.rb:409 + def task_defined?(task_name); end + + # List of all defined tasks. + # + # source://rake-13.0.6/lib/rake/task.rb:396 + def tasks; end + end +end + +# Error indicating an ill-formed task declaration. +# +# source://rake-13.0.6/lib/rake/task_argument_error.rb:5 +class Rake::TaskArgumentError < ::ArgumentError; end + +# TaskArguments manage the arguments passed to a task. +# +# source://rake-13.0.6/lib/rake/task_arguments.rb:7 +class Rake::TaskArguments + include ::Enumerable + + # Create a TaskArgument object with a list of argument +names+ and a set + # of associated +values+. +parent+ is the parent argument object. + # + # @return [TaskArguments] a new instance of TaskArguments + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:15 + def initialize(names, values, parent = T.unsafe(nil)); end + + # Find an argument value by name or index. + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:44 + def [](index); end + + # Enumerates the arguments and their values + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:56 + def each(&block); end + + # Retrieve the list of values not associated with named arguments + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:32 + def extras; end + + # source://rake-13.0.6/lib/rake/task_arguments.rb:93 + def fetch(*args, &block); end + + # Returns true if +key+ is one of the arguments + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:88 + def has_key?(key); end + + # source://rake-13.0.6/lib/rake/task_arguments.rb:79 + def inspect; end + + # Returns true if +key+ is one of the arguments + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:88 + def key?(key); end + + # Returns the value of the given argument via method_missing + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:66 + def method_missing(sym, *args); end + + # Argument names + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:11 + def names; end + + # Create a new argument scope using the prerequisite argument + # names. + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:38 + def new_scope(names); end + + # Retrieve the complete array of sequential values + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:27 + def to_a; end + + # Returns a Hash of arguments and their values + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:71 + def to_hash; end + + # source://rake-13.0.6/lib/rake/task_arguments.rb:75 + def to_s; end + + # Extracts the argument values at +keys+ + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:61 + def values_at(*keys); end + + # Specify a hash of default values for task arguments. Use the + # defaults only if there is no specific value for the given + # argument. + # + # source://rake-13.0.6/lib/rake/task_arguments.rb:51 + def with_defaults(defaults); end + + protected + + # source://rake-13.0.6/lib/rake/task_arguments.rb:99 + def lookup(name); end +end + +# Base class for Task Libraries. +# +# source://rake-13.0.6/lib/rake/tasklib.rb:7 +class Rake::TaskLib + include ::Rake::Cloneable + include ::FileUtils::StreamUtils_ + include ::FileUtils + include ::Rake::FileUtilsExt + include ::Rake::DSL +end + +# The TaskManager module is a mixin for managing tasks. +# +# source://rake-13.0.6/lib/rake/task_manager.rb:5 +module Rake::TaskManager + # source://rake-13.0.6/lib/rake/task_manager.rb:9 + def initialize; end + + # Find a matching task for +task_name+. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:54 + def [](task_name, scopes = T.unsafe(nil)); end + + # Clear all tasks in this application. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:182 + def clear; end + + # source://rake-13.0.6/lib/rake/task_manager.rb:17 + def create_rule(*args, &block); end + + # Return the list of scope names currently active in the task + # manager. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:222 + def current_scope; end + + # source://rake-13.0.6/lib/rake/task_manager.rb:23 + def define_task(task_class, *args, &block); end + + # If a rule can be found that matches the task name, enhance the + # task with the prerequisites and actions from the rule. Set the + # source attribute of the task appropriately for the rule. Return + # the enhanced task or nil of no rule was found. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:151 + def enhance_with_matching_rule(task_name, level = T.unsafe(nil)); end + + # source://rake-13.0.6/lib/rake/task_manager.rb:68 + def generate_did_you_mean_suggestions(task_name); end + + # source://rake-13.0.6/lib/rake/task_manager.rb:62 + def generate_message_for_undefined_task(task_name); end + + # Evaluate the block in a nested namespace named +name+. Create + # an anonymous namespace if +name+ is nil. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:228 + def in_namespace(name); end + + # Lookup a task. Return an existing task if found, otherwise + # create a task of the current type. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:49 + def intern(task_class, task_name); end + + # Track the last comment made in the Rakefile. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:7 + def last_description; end + + # Track the last comment made in the Rakefile. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:7 + def last_description=(_arg0); end + + # Lookup a task, using scope and the scope hints in the task name. + # This method performs straight lookups without trying to + # synthesize file tasks or rules. Special scope names (e.g. '^') + # are recognized. If no scope argument is supplied, use the + # current scope. Return nil if the task cannot be found. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:192 + def lookup(task_name, initial_scope = T.unsafe(nil)); end + + # Resolve the arguments for a task/rule. Returns a tuple of + # [task_name, arg_name_list, prerequisites, order_only_prerequisites]. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:88 + def resolve_args(args); end + + # source://rake-13.0.6/lib/rake/task_manager.rb:81 + def synthesize_file_task(task_name); end + + # List of all defined tasks in this application. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:168 + def tasks; end + + # List of all the tasks defined in the given scope (and its + # sub-scopes). + # + # source://rake-13.0.6/lib/rake/task_manager.rb:174 + def tasks_in_scope(scope); end + + private + + # Add a location to the locations field of the given task. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:241 + def add_location(task); end + + # Attempt to create a rule given the list of prerequisites. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:271 + def attempt_rule(task_name, task_pattern, args, extensions, block, level); end + + # Find the location that called into the dsl layer. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:248 + def find_location; end + + # Generate an anonymous namespace name. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:259 + def generate_name; end + + # Return the current description, clearing it in the process. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:319 + def get_description(task); end + + # Lookup the task name + # + # source://rake-13.0.6/lib/rake/task_manager.rb:208 + def lookup_in_scope(name, scope); end + + # Make a list of sources from the list of file name extensions / + # translation procs. + # + # source://rake-13.0.6/lib/rake/task_manager.rb:293 + def make_sources(task_name, task_pattern, extensions); end + + # Resolve task arguments for a task or rule when there are + # dependencies declared. + # + # The patterns recognized by this argument resolving function are: + # + # task :t, order_only: [:e] + # task :t => [:d] + # task :t => [:d], order_only: [:e] + # task :t, [a] => [:d] + # task :t, [a] => [:d], order_only: [:e] + # + # source://rake-13.0.6/lib/rake/task_manager.rb:127 + def resolve_args_with_dependencies(args, hash); end + + # Resolve task arguments for a task or rule when there are no + # dependencies declared. + # + # The patterns recognized by this argument resolving function are: + # + # task :t + # task :t, [:a] + # + # source://rake-13.0.6/lib/rake/task_manager.rb:105 + def resolve_args_without_dependencies(args); end + + # source://rake-13.0.6/lib/rake/task_manager.rb:265 + def trace_rule(level, message); end + + class << self + # source://rake-13.0.6/lib/rake/task_manager.rb:326 + def record_task_metadata; end + + # source://rake-13.0.6/lib/rake/task_manager.rb:326 + def record_task_metadata=(_arg0); end + end +end + +# source://rake-13.0.6/lib/rake/thread_history_display.rb:6 +class Rake::ThreadHistoryDisplay + include ::Rake::PrivateReader + extend ::Rake::PrivateReader::ClassMethods + + # @return [ThreadHistoryDisplay] a new instance of ThreadHistoryDisplay + # + # source://rake-13.0.6/lib/rake/thread_history_display.rb:11 + def initialize(stats); end + + # source://rake-13.0.6/lib/rake/thread_history_display.rb:17 + def show; end + + private + + # source://rake-13.0.6/lib/rake/private_reader.rb:15 + def items; end + + # source://rake-13.0.6/lib/rake/thread_history_display.rb:35 + def rename(hash, key, renames); end + + # source://rake-13.0.6/lib/rake/private_reader.rb:15 + def stats; end + + # source://rake-13.0.6/lib/rake/private_reader.rb:15 + def threads; end +end + +# source://rake-13.0.6/lib/rake/thread_pool.rb:7 +class Rake::ThreadPool + # Creates a ThreadPool object. The +thread_count+ parameter is the size + # of the pool. + # + # @return [ThreadPool] a new instance of ThreadPool + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:11 + def initialize(thread_count); end + + # Creates a future executed by the +ThreadPool+. + # + # The args are passed to the block when executing (similarly to + # Thread#new) The return value is an object representing + # a future which has been created and added to the queue in the + # pool. Sending #value to the object will sleep the + # current thread until the future is finished and will return the + # result (or raise an exception thrown from the future) + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:33 + def future(*args, &block); end + + # Enable the gathering of history events. + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:68 + def gather_history; end + + # Return a array of history events for the thread pool. + # + # History gathering must be enabled to be able to see the events + # (see #gather_history). Best to call this when the job is + # complete (i.e. after ThreadPool#join is called). + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:77 + def history; end + + # Waits until the queue of futures is empty and all threads have exited. + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:44 + def join; end + + # Return a hash of always collected statistics for the thread pool. + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:84 + def statistics; end + + private + + # for testing only + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:158 + def __queue__; end + + # processes one item on the queue. Returns true if there was an + # item to process, false if there was no item + # + # source://rake-13.0.6/lib/rake/thread_pool.rb:95 + def process_queue_item; end + + # source://rake-13.0.6/lib/rake/thread_pool.rb:111 + def safe_thread_count; end + + # source://rake-13.0.6/lib/rake/thread_pool.rb:117 + def start_thread; end + + # source://rake-13.0.6/lib/rake/thread_pool.rb:145 + def stat(event, data = T.unsafe(nil)); end +end + +# source://rake-13.0.6/lib/rake/trace_output.rb:3 +module Rake::TraceOutput + # Write trace output to output stream +out+. + # + # The write is done as a single IO call (to print) to lessen the + # chance that the trace output is interrupted by other tasks also + # producing output. + # + # source://rake-13.0.6/lib/rake/trace_output.rb:10 + def trace_on(out, *strings); end +end + +# source://rake-13.0.6/lib/rake/version.rb:3 +Rake::VERSION = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/version.rb:5 +module Rake::Version; end + +# source://rake-13.0.6/lib/rake/version.rb:6 +Rake::Version::BUILD = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/version.rb:6 +Rake::Version::MAJOR = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/version.rb:6 +Rake::Version::MINOR = T.let(T.unsafe(nil), String) + +# source://rake-13.0.6/lib/rake/version.rb:8 +Rake::Version::NUMBERS = T.let(T.unsafe(nil), Array) + +# source://rake-13.0.6/lib/rake/version.rb:6 +Rake::Version::OTHER = T.let(T.unsafe(nil), Array) + +# Win 32 interface methods for Rake. Windows specific functionality +# will be placed here to collect that knowledge in one spot. +# +# source://rake-13.0.6/lib/rake/win32.rb:7 +module Rake::Win32 + class << self + # Normalize a win32 path so that the slashes are all forward slashes. + # + # source://rake-13.0.6/lib/rake/win32.rb:45 + def normalize(path); end + + # The standard directory containing system wide rake files on + # Win 32 systems. Try the following environment variables (in + # order): + # + # * HOME + # * HOMEDRIVE + HOMEPATH + # * APPDATA + # * USERPROFILE + # + # If the above are not defined, the return nil. + # + # @raise [Win32HomeError] + # + # source://rake-13.0.6/lib/rake/win32.rb:30 + def win32_system_dir; end + + # True if running on a windows system. + # + # @return [Boolean] + # + # source://rake-13.0.6/lib/rake/win32.rb:16 + def windows?; end + end +end + +# Error indicating a problem in locating the home directory on a +# Win32 system. +# +# source://rake-13.0.6/lib/rake/win32.rb:11 +class Rake::Win32::Win32HomeError < ::RuntimeError; end + +# source://rake-13.0.6/lib/rake.rb:71 +RakeFileUtils = Rake::FileUtilsExt + +# source://rake-13.0.6/lib/rake/ext/string.rb:4 +class String + include ::Comparable + + # source://rake-13.0.6/lib/rake/ext/string.rb:14 + def ext(newext = T.unsafe(nil)); end + + # source://rake-13.0.6/lib/rake/ext/string.rb:138 + def pathmap(spec = T.unsafe(nil), &block); end + + protected + + # source://rake-13.0.6/lib/rake/ext/string.rb:27 + def pathmap_explode; end + + # source://rake-13.0.6/lib/rake/ext/string.rb:41 + def pathmap_partial(n); end + + # source://rake-13.0.6/lib/rake/ext/string.rb:59 + def pathmap_replace(patterns, &block); end +end diff --git a/sorbet/rbi/gems/rbi@0.0.15.rbi b/sorbet/rbi/gems/rbi@0.0.15.rbi new file mode 100644 index 00000000..fc75efed --- /dev/null +++ b/sorbet/rbi/gems/rbi@0.0.15.rbi @@ -0,0 +1,3007 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rbi` gem. +# Please instead update this file by running `bin/tapioca gem rbi`. + +# source://rbi-0.0.15/lib/rbi.rb:7 +module RBI; end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/parser.rb:129 +class RBI::ASTVisitor + abstract! + + # source://sorbet-runtime-0.5.10346/lib/types/private/abstract/declare.rb:37 + def initialize(*args, &blk); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/parser.rb:141 + sig { abstract.params(node: T.nilable(::AST::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:136 + sig { params(nodes: T::Array[::AST::Node]).void } + def visit_all(nodes); end + + private + + # source://rbi-0.0.15/lib/rbi/parser.rb:151 + sig { params(node: ::AST::Node).returns(::String) } + def parse_expr(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:146 + sig { params(node: ::AST::Node).returns(::String) } + def parse_name(node); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:960 +class RBI::Arg < ::RBI::Node + # source://rbi-0.0.15/lib/rbi/model.rb:972 + sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void } + def initialize(value, loc: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:978 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:611 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:983 + sig { returns(::String) } + def to_s; end + + # source://rbi-0.0.15/lib/rbi/model.rb:964 + sig { returns(::String) } + def value; end +end + +# Attributes +# +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:341 +class RBI::Attr < ::RBI::NodeWithComments + include ::RBI::Indexable + + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:366 + sig do + params( + name: ::Symbol, + names: T::Array[::Symbol], + visibility: ::RBI::Visibility, + sigs: T::Array[::RBI::Sig], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment] + ).void + end + def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:346 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:406 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/model.rb:374 + sig { abstract.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/index.rb:109 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:413 + sig { override.params(other: ::RBI::Node).void } + def merge_with(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:348 + sig { returns(T::Array[::Symbol]) } + def names; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:348 + def names=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:373 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:354 + sig { returns(T::Array[::RBI::Sig]) } + def sigs; end + + # source://rbi-0.0.15/lib/rbi/model.rb:351 + sig { returns(::RBI::Visibility) } + def visibility; end + + # @return [Visibility] + # + # source://rbi-0.0.15/lib/rbi/model.rb:351 + def visibility=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:377 +class RBI::AttrAccessor < ::RBI::Attr + # source://rbi-0.0.15/lib/rbi/model.rb:391 + sig do + params( + name: ::Symbol, + names: ::Symbol, + visibility: ::RBI::Visibility, + sigs: T::Array[::RBI::Sig], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::AttrAccessor).void) + ).void + end + def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:444 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:397 + sig { override.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/model.rb:403 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:409 +class RBI::AttrReader < ::RBI::Attr + # source://rbi-0.0.15/lib/rbi/model.rb:423 + sig do + params( + name: ::Symbol, + names: ::Symbol, + visibility: ::RBI::Visibility, + sigs: T::Array[::RBI::Sig], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::AttrReader).void) + ).void + end + def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:426 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:429 + sig { override.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/model.rb:435 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:441 +class RBI::AttrWriter < ::RBI::Attr + # source://rbi-0.0.15/lib/rbi/model.rb:455 + sig do + params( + name: ::Symbol, + names: ::Symbol, + visibility: ::RBI::Visibility, + sigs: T::Array[::RBI::Sig], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::AttrWriter).void) + ).void + end + def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:435 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:461 + sig { override.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/model.rb:467 + sig { override.returns(::String) } + def to_s; end +end + +# An arbitrary blank line that can be added both in trees and comments +# +# source://rbi-0.0.15/lib/rbi/model.rb:70 +class RBI::BlankLine < ::RBI::Comment + # source://rbi-0.0.15/lib/rbi/model.rb:74 + sig { params(loc: T.nilable(::RBI::Loc)).void } + def initialize(loc: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:215 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:733 +class RBI::BlockParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:744 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::BlockParam).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:755 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:541 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:546 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:750 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:213 +class RBI::Class < ::RBI::Scope + # source://rbi-0.0.15/lib/rbi/model.rb:231 + sig do + params( + name: ::String, + superclass_name: T.nilable(::String), + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Class).void) + ).void + end + def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:370 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:239 + sig { override.returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:217 + sig { returns(::String) } + def name; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:217 + def name=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:282 + sig { override.params(v: ::RBI::Printer).void } + def print_header(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:220 + sig { returns(T.nilable(::String)) } + def superclass_name; end + + # @return [String, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:220 + def superclass_name=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:50 +class RBI::Comment < ::RBI::Node + # source://rbi-0.0.15/lib/rbi/model.rb:57 + sig { params(text: ::String, loc: T.nilable(::RBI::Loc)).void } + def initialize(text, loc: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:63 + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:195 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:54 + sig { returns(::String) } + def text; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:54 + def text=(_arg0); end +end + +# A tree showing incompatibles nodes +# +# Is rendered as a merge conflict between `left` and` right`: +# ~~~rb +# class Foo +# <<<<<<< left +# def m1; end +# def m2(a); end +# ======= +# def m1(a); end +# def m2; end +# >>>>>>> right +# end +# ~~~ +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:578 +class RBI::ConflictTree < ::RBI::Tree + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:585 + sig { params(left_name: ::String, right_name: ::String).void } + def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:596 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:582 + sig { returns(::RBI::Tree) } + def left; end + + # @return [Tree] + # + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:582 + def right; end +end + +# Consts +# +# source://rbi-0.0.15/lib/rbi/model.rb:305 +class RBI::Const < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:320 + sig do + params( + name: ::String, + value: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Const).void) + ).void + end + def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:333 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:397 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:328 + sig { returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/index.rb:99 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:309 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:334 + sig { override.returns(::String) } + def to_s; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:309 + def value; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:600 +class RBI::ConstBuilder < ::RBI::ASTVisitor + # source://rbi-0.0.15/lib/rbi/parser.rb:615 + sig { void } + def initialize; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:612 + sig { returns(T::Array[::String]) } + def names; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/parser.rb:612 + def names=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:621 + sig { override.params(node: T.nilable(::AST::Node)).void } + def visit(node); end + + class << self + # source://rbi-0.0.15/lib/rbi/parser.rb:604 + sig { params(node: T.nilable(::AST::Node)).returns(T.nilable(::String)) } + def visit(node); end + end +end + +# source://rbi-0.0.15/lib/rbi.rb:8 +class RBI::Error < ::StandardError; end + +# source://rbi-0.0.15/lib/rbi/model.rb:808 +class RBI::Extend < ::RBI::Mixin + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:820 + sig do + params( + name: ::String, + names: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Extend).void) + ).void + end + def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:492 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/index.rb:139 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:826 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:133 +class RBI::File + # source://rbi-0.0.15/lib/rbi/model.rb:152 + sig do + params( + strictness: T.nilable(::String), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(file: ::RBI::File).void) + ).void + end + def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:160 + sig { params(node: ::RBI::Node).void } + def <<(node); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:104 + sig { params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:143 + sig { returns(T::Array[::RBI::Comment]) } + def comments; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:143 + def comments=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:165 + sig { returns(T::Boolean) } + def empty?; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:128 + sig do + params( + out: T.any(::IO, ::StringIO), + indent: ::Integer, + print_locs: T::Boolean, + max_line_length: T.nilable(::Integer) + ).void + end + def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:137 + sig { returns(::RBI::Tree) } + def root; end + + # @return [Tree] + # + # source://rbi-0.0.15/lib/rbi/model.rb:137 + def root=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:140 + sig { returns(T.nilable(::String)) } + def strictness; end + + # @return [String, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:140 + def strictness=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:134 + sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } + def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end +end + +# source://rbi-0.0.15/lib/rbi/formatter.rb:5 +class RBI::Formatter + # source://rbi-0.0.15/lib/rbi/formatter.rb:24 + sig do + params( + add_sig_templates: T::Boolean, + group_nodes: T::Boolean, + max_line_length: T.nilable(::Integer), + nest_singleton_methods: T::Boolean, + nest_non_public_methods: T::Boolean, + sort_nodes: T::Boolean + ).void + end + def initialize(add_sig_templates: T.unsafe(nil), group_nodes: T.unsafe(nil), max_line_length: T.unsafe(nil), nest_singleton_methods: T.unsafe(nil), nest_non_public_methods: T.unsafe(nil), sort_nodes: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + sig { returns(T::Boolean) } + def add_sig_templates; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def add_sig_templates=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:53 + sig { params(file: ::RBI::File).void } + def format_file(file); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:58 + sig { params(tree: ::RBI::Tree).void } + def format_tree(tree); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def group_nodes; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def group_nodes=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:12 + sig { returns(T.nilable(::Integer)) } + def max_line_length; end + + # @return [Integer, nil] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:12 + def max_line_length=(_arg0); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def nest_non_public_methods; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def nest_non_public_methods=(_arg0); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def nest_singleton_methods; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def nest_singleton_methods=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:41 + sig { params(file: ::RBI::File).returns(::String) } + def print_file(file); end + + # source://rbi-0.0.15/lib/rbi/formatter.rb:47 + sig { params(tree: ::RBI::Tree).returns(::String) } + def print_tree(tree); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def sort_nodes; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/formatter.rb:9 + def sort_nodes=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:88 +class RBI::Group < ::RBI::Tree + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:95 + sig { params(kind: ::RBI::Group::Kind).void } + def initialize(kind); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:836 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:92 + sig { returns(::RBI::Group::Kind) } + def kind; end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:100 +class RBI::Group::Kind < ::T::Enum + enums do + Mixins = new + RequiredAncestors = new + Helpers = new + TypeMembers = new + MixesInClassMethods = new + Sends = new + Attrs = new + TStructFields = new + TEnums = new + Inits = new + Methods = new + SingletonClasses = new + Consts = new + end +end + +# Sorbet's misc. +# +# source://rbi-0.0.15/lib/rbi/model.rb:1285 +class RBI::Helper < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1299 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Helper).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:823 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:510 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/index.rb:169 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1289 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1306 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:785 +class RBI::Include < ::RBI::Mixin + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:797 + sig do + params( + name: ::String, + names: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Include).void) + ).void + end + def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:483 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/index.rb:129 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:803 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/index.rb:5 +class RBI::Index < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/index.rb:17 + sig { void } + def initialize; end + + # source://rbi-0.0.15/lib/rbi/index.rb:28 + sig { params(id: ::String).returns(T::Array[::RBI::Node]) } + def [](id); end + + # source://rbi-0.0.15/lib/rbi/index.rb:33 + sig { params(nodes: ::RBI::Node).void } + def index(*nodes); end + + # source://rbi-0.0.15/lib/rbi/index.rb:23 + sig { returns(T::Array[::String]) } + def keys; end + + # source://rbi-0.0.15/lib/rbi/index.rb:38 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/index.rb:55 + sig { params(node: T.all(::RBI::Indexable, ::RBI::Node)).void } + def index_node(node); end + + class << self + # source://rbi-0.0.15/lib/rbi/index.rb:10 + sig { params(node: ::RBI::Node).returns(::RBI::Index) } + def index(*node); end + end +end + +# A Node that can be refered to by a unique ID inside an index +# +# @abstract Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/index.rb:70 +module RBI::Indexable + interface! + + # Unique IDs that refer to this node. + # + # Some nodes can have multiple ids, for example an attribute accessor matches the ID of the + # getter and the setter. + # + # @abstract + # + # source://rbi-0.0.15/lib/rbi/index.rb:81 + sig { abstract.returns(T::Array[::String]) } + def index_ids; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:988 +class RBI::KwArg < ::RBI::Arg + # source://rbi-0.0.15/lib/rbi/model.rb:1001 + sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void } + def initialize(keyword, value, loc: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1007 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:620 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:992 + sig { returns(::String) } + def keyword; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1012 + sig { returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:674 +class RBI::KwOptParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:689 + sig do + params( + name: ::String, + value: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::KwOptParam).void) + ).void + end + def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:701 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:511 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:516 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:696 + sig { override.returns(::String) } + def to_s; end + + # source://rbi-0.0.15/lib/rbi/model.rb:678 + sig { returns(::String) } + def value; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:647 +class RBI::KwParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:658 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::KwParam).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:669 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:496 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:501 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:664 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:706 +class RBI::KwRestParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:717 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::KwRestParam).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:728 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:526 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:531 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:723 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/loc.rb:5 +class RBI::Loc + # source://rbi-0.0.15/lib/rbi/loc.rb:23 + sig do + params( + file: T.nilable(::String), + begin_line: T.nilable(::Integer), + end_line: T.nilable(::Integer), + begin_column: T.nilable(::Integer), + end_column: T.nilable(::Integer) + ).void + end + def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end + + # @return [Integer, nil] + # + # source://rbi-0.0.15/lib/rbi/loc.rb:12 + def begin_column; end + + # source://rbi-0.0.15/lib/rbi/loc.rb:12 + sig { returns(T.nilable(::Integer)) } + def begin_line; end + + # @return [Integer, nil] + # + # source://rbi-0.0.15/lib/rbi/loc.rb:12 + def end_column; end + + # @return [Integer, nil] + # + # source://rbi-0.0.15/lib/rbi/loc.rb:12 + def end_line; end + + # source://rbi-0.0.15/lib/rbi/loc.rb:9 + sig { returns(T.nilable(::String)) } + def file; end + + # source://rbi-0.0.15/lib/rbi/loc.rb:37 + sig { returns(T.nilable(::String)) } + def source; end + + # source://rbi-0.0.15/lib/rbi/loc.rb:32 + sig { returns(::String) } + def to_s; end + + class << self + # source://rbi-0.0.15/lib/rbi/parser.rb:707 + sig { params(file: ::String, ast_loc: T.any(::Parser::Source::Map, ::Parser::Source::Range)).returns(::RBI::Loc) } + def from_ast_loc(file, ast_loc); end + end +end + +# A tree that _might_ contain conflicts +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:324 +class RBI::MergeTree < ::RBI::Tree + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:338 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + conflicts: T::Array[::RBI::Rewriters::Merge::Conflict], + block: T.nilable(T.proc.params(node: ::RBI::Tree).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), conflicts: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:328 + sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) } + def conflicts; end +end + +# Methods and args +# +# source://rbi-0.0.15/lib/rbi/model.rb:475 +class RBI::Method < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:505 + sig do + params( + name: ::String, + params: T::Array[::RBI::Param], + is_singleton: T::Boolean, + visibility: ::RBI::Visibility, + sigs: T::Array[::RBI::Sig], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Method).void) + ).void + end + def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:525 + sig { params(param: ::RBI::Param).void } + def <<(param); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:382 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:453 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:530 + sig { returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/index.rb:119 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:435 + sig { returns(T::Boolean) } + def inline_params?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:485 + sig { returns(T::Boolean) } + def is_singleton; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:485 + def is_singleton=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:461 + sig { override.params(other: ::RBI::Node).void } + def merge_with(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:479 + sig { returns(::String) } + def name; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:479 + def name=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:430 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:482 + sig { returns(T::Array[::RBI::Param]) } + def params; end + + # source://rbi-0.0.15/lib/rbi/model.rb:491 + sig { returns(T::Array[::RBI::Sig]) } + def sigs; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:491 + def sigs=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:539 + sig { override.returns(::String) } + def to_s; end + + # source://rbi-0.0.15/lib/rbi/model.rb:488 + sig { returns(::RBI::Visibility) } + def visibility; end + + # @return [Visibility] + # + # source://rbi-0.0.15/lib/rbi/model.rb:488 + def visibility=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1345 +class RBI::MixesInClassMethods < ::RBI::Mixin + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1357 + sig do + params( + name: ::String, + names: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::MixesInClassMethods).void) + ).void + end + def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:501 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/index.rb:149 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1363 + sig { override.returns(::String) } + def to_s; end +end + +# Mixins +# +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:762 +class RBI::Mixin < ::RBI::NodeWithComments + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:779 + sig do + params( + name: ::String, + names: T::Array[::String], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment] + ).void + end + def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:556 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:474 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:769 + sig { returns(T::Array[::String]) } + def names; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:769 + def names=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:186 +class RBI::Module < ::RBI::Scope + # source://rbi-0.0.15/lib/rbi/model.rb:200 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Module).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:379 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:207 + sig { override.returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:190 + sig { returns(::String) } + def name; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:190 + def name=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:268 + sig { override.params(v: ::RBI::Printer).void } + def print_header(v); end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:5 +class RBI::Node + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:18 + sig { params(loc: T.nilable(::RBI::Loc)).void } + def initialize(loc: T.unsafe(nil)); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/printer.rb:145 + sig { abstract.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # Can `self` and `_other` be merged into a single definition? + # + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:283 + sig { params(_other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(_other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:24 + sig { void } + def detach; end + + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:48 + sig { returns(::RBI::Group::Kind) } + def group_kind; end + + # source://rbi-0.0.15/lib/rbi/model.rb:15 + sig { returns(T.nilable(::RBI::Loc)) } + def loc; end + + # @return [Loc, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:15 + def loc=(_arg0); end + + # Merge `self` and `other` into a single definition + # + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:289 + sig { params(other: ::RBI::Node).void } + def merge_with(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:177 + sig { returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:292 + sig { returns(T.nilable(::RBI::ConflictTree)) } + def parent_conflict_tree; end + + # source://rbi-0.0.15/lib/rbi/model.rb:43 + sig { returns(T.nilable(::RBI::Scope)) } + def parent_scope; end + + # source://rbi-0.0.15/lib/rbi/model.rb:12 + sig { returns(T.nilable(::RBI::Tree)) } + def parent_tree; end + + # @return [Tree, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:12 + def parent_tree=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:155 + sig do + params( + out: T.any(::IO, ::StringIO), + indent: ::Integer, + print_locs: T::Boolean, + max_line_length: T.nilable(::Integer) + ).void + end + def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:168 + sig { params(v: ::RBI::Printer).void } + def print_blank_line_before(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:32 + sig { params(node: ::RBI::Node).void } + def replace(node); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:161 + sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } + def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:79 +class RBI::NodeWithComments < ::RBI::Node + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:89 + sig { params(loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void } + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:95 + sig { returns(T::Array[::String]) } + def annotations; end + + # source://rbi-0.0.15/lib/rbi/model.rb:86 + sig { returns(T::Array[::RBI::Comment]) } + def comments; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:86 + def comments=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:306 + sig { override.params(other: ::RBI::Node).void } + def merge_with(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:186 + sig { override.returns(T::Boolean) } + def oneline?; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:593 +class RBI::OptParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:608 + sig do + params( + name: ::String, + value: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::OptParam).void) + ).void + end + def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:615 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:466 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:471 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:597 + sig { returns(::String) } + def value; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:544 +class RBI::Param < ::RBI::NodeWithComments + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:560 + sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void } + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:444 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:457 + sig { returns(T::Array[::String]) } + def comments_lines; end + + # source://rbi-0.0.15/lib/rbi/model.rb:551 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:449 + sig { params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:566 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:7 +class RBI::ParseError < ::StandardError + # source://rbi-0.0.15/lib/rbi/parser.rb:14 + sig { params(message: ::String, location: ::RBI::Loc).void } + def initialize(message, location); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:11 + sig { returns(::RBI::Loc) } + def location; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:53 +class RBI::Parser + # source://rbi-0.0.15/lib/rbi/parser.rb:64 + sig { void } + def initialize; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:97 + sig { params(path: ::String).returns(::RBI::Tree) } + def parse_file(path); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:86 + sig { params(string: ::String).returns(::RBI::Tree) } + def parse_string(string); end + + private + + # source://rbi-0.0.15/lib/rbi/parser.rb:104 + sig { params(content: ::String, file: ::String).returns(::RBI::Tree) } + def parse(content, file:); end + + class << self + # source://rbi-0.0.15/lib/rbi/parser.rb:75 + sig { params(path: ::String).returns(::RBI::Tree) } + def parse_file(path); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:80 + sig { params(paths: T::Array[::String]).returns(T::Array[::RBI::Tree]) } + def parse_files(paths); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:70 + sig { params(string: ::String).returns(::RBI::Tree) } + def parse_string(string); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:91 + sig { params(strings: T::Array[::String]).returns(T::Array[::RBI::Tree]) } + def parse_strings(strings); end + end +end + +# source://rbi-0.0.15/lib/rbi/printer.rb:5 +class RBI::Printer < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/printer.rb:28 + sig do + params( + out: T.any(::IO, ::StringIO), + indent: ::Integer, + print_locs: T::Boolean, + max_line_length: T.nilable(::Integer) + ).void + end + def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:15 + sig { returns(::Integer) } + def current_indent; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:46 + sig { void } + def dedent; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/printer.rb:9 + def in_visibility_group; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/printer.rb:9 + def in_visibility_group=(_arg0); end + + # Printing + # + # source://rbi-0.0.15/lib/rbi/printer.rb:41 + sig { void } + def indent; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:18 + sig { returns(T.nilable(::Integer)) } + def max_line_length; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:12 + sig { returns(T.nilable(::RBI::Node)) } + def previous_node; end + + # Print a string without indentation nor `\n` at the end. + # + # source://rbi-0.0.15/lib/rbi/printer.rb:52 + sig { params(string: ::String).void } + def print(string); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:9 + sig { returns(T::Boolean) } + def print_locs; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/printer.rb:9 + def print_locs=(_arg0); end + + # Print a string with indentation and `\n` at the end. + # + # source://rbi-0.0.15/lib/rbi/printer.rb:72 + sig { params(string: ::String).void } + def printl(string); end + + # Print a string without indentation but with a `\n` at the end. + # + # source://rbi-0.0.15/lib/rbi/printer.rb:58 + sig { params(string: T.nilable(::String)).void } + def printn(string = T.unsafe(nil)); end + + # Print a string with indentation but without a `\n` at the end. + # + # source://rbi-0.0.15/lib/rbi/printer.rb:65 + sig { params(string: T.nilable(::String)).void } + def printt(string = T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:83 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:89 + sig { override.params(nodes: T::Array[::RBI::Node]).void } + def visit_all(nodes); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:78 + sig { params(file: ::RBI::File).void } + def visit_file(file); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:901 +class RBI::Private < ::RBI::Visibility + # source://rbi-0.0.15/lib/rbi/model.rb:911 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Private).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:885 +class RBI::Protected < ::RBI::Visibility + # source://rbi-0.0.15/lib/rbi/model.rb:895 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Protected).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:869 +class RBI::Public < ::RBI::Visibility + # source://rbi-0.0.15/lib/rbi/model.rb:879 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Public).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:571 +class RBI::ReqParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:582 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::ReqParam).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:588 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1368 +class RBI::RequiresAncestor < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1381 + sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void } + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:868 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/index.rb:159 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1372 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1387 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:620 +class RBI::RestParam < ::RBI::Param + # source://rbi-0.0.15/lib/rbi/model.rb:631 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::RestParam).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:642 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:481 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:486 + sig { override.params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # source://rbi-0.0.15/lib/rbi/model.rb:637 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:5 +module RBI::Rewriters; end + +# source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:6 +class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:10 + sig { params(with_todo_comment: T::Boolean).void } + def initialize(with_todo_comment: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:16 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:30 + sig { params(attr: ::RBI::Attr).void } + def add_attr_sig(attr); end + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:45 + sig { params(method: ::RBI::Method).void } + def add_method_sig(method); end + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:56 + sig { params(node: ::RBI::NodeWithComments).void } + def add_todo_comment(node); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:6 +class RBI::Rewriters::Annotate < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:10 + sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void } + def initialize(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:18 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:31 + sig { params(node: ::RBI::NodeWithComments).void } + def annotate_node(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:37 + sig { params(node: ::RBI::Node).returns(T::Boolean) } + def root?(node); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:6 +class RBI::Rewriters::Deannotate < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:10 + sig { params(annotation: ::String).void } + def initialize(annotation); end + + # source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:16 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:27 + sig { params(node: ::RBI::NodeWithComments).void } + def deannotate_node(node); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:6 +class RBI::Rewriters::GroupNodes < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:10 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end +end + +# Merge two RBI trees together +# +# Be this `Tree`: +# ~~~rb +# class Foo +# attr_accessor :a +# def m; end +# C = 10 +# end +# ~~~ +# +# Merged with this one: +# ~~~rb +# class Foo +# attr_reader :a +# def m(x); end +# C = 10 +# end +# ~~~ +# +# Compatible definitions are merged together while incompatible definitions are moved into a `ConflictTree`: +# ~~~rb +# class Foo +# <<<<<<< left +# attr_accessor :a +# def m; end +# ======= +# attr_reader :a +# def m(x); end +# >>>>>>> right +# C = 10 +# end +# ~~~ +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:39 +class RBI::Rewriters::Merge + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:66 + sig { params(left_name: ::String, right_name: ::String, keep: ::RBI::Rewriters::Merge::Keep).void } + def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:75 + sig { params(tree: ::RBI::Tree).void } + def merge(tree); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:63 + sig { returns(::RBI::MergeTree) } + def tree; end + + class << self + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:51 + sig do + params( + left: ::RBI::Tree, + right: ::RBI::Tree, + left_name: ::String, + right_name: ::String, + keep: ::RBI::Rewriters::Merge::Keep + ).returns(::RBI::MergeTree) + end + def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end + end +end + +# Used for logging / error displaying purpose +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:82 +class RBI::Rewriters::Merge::Conflict < ::T::Struct + const :left, ::RBI::Node + const :left_name, ::String + const :right, ::RBI::Node + const :right_name, ::String + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:91 + sig { returns(::String) } + def to_s; end + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# Merge adjacent conflict trees +# +# Transform this: +# ~~~rb +# class Foo +# <<<<<<< left +# def m1; end +# ======= +# def m1(a); end +# >>>>>>> right +# <<<<<<< left +# def m2(a); end +# ======= +# def m2; end +# >>>>>>> right +# end +# ~~~ +# +# Into this: +# ~~~rb +# class Foo +# <<<<<<< left +# def m1; end +# def m2(a); end +# ======= +# def m1(a); end +# def m2; end +# >>>>>>> right +# end +# ~~~ +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:241 +class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:243 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:248 + sig { override.params(nodes: T::Array[::RBI::Node]).void } + def visit_all(nodes); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:269 + sig { params(left: ::RBI::Tree, right: ::RBI::Tree).void } + def merge_conflict_trees(left, right); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:42 +class RBI::Rewriters::Merge::Keep < ::T::Enum + enums do + NONE = new + LEFT = new + RIGHT = new + end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:96 +class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:103 + sig do + params( + output: ::RBI::Tree, + left_name: ::String, + right_name: ::String, + keep: ::RBI::Rewriters::Merge::Keep + ).void + end + def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:100 + sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) } + def conflicts; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:115 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:164 + sig { returns(::RBI::Tree) } + def current_scope; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:181 + sig { params(left: ::RBI::Scope, right: ::RBI::Scope).void } + def make_conflict_scope(left, right); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:188 + sig { params(left: ::RBI::Node, right: ::RBI::Node).void } + def make_conflict_tree(left, right); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:169 + sig { params(node: ::RBI::Node).returns(T.nilable(::RBI::Node)) } + def previous_definition(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:200 + sig { params(left: ::RBI::Scope, right: ::RBI::Scope).returns(::RBI::Scope) } + def replace_scope_header(left, right); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:6 +class RBI::Rewriters::NestNonPublicMethods < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:10 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/nest_singleton_methods.rb:6 +class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/nest_singleton_methods.rb:10 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end +end + +# Remove all definitions existing in the index from the current tree +# +# Let's create an `Index` from two different `Tree`s: +# ~~~rb +# tree1 = Parse.parse_string(<<~RBI) +# class Foo +# def foo; end +# end +# RBI +# +# tree2 = Parse.parse_string(<<~RBI) +# FOO = 10 +# RBI +# +# index = Index.index(tree1, tree2) +# ~~~ +# +# We can use `RemoveKnownDefinitions` to remove the definitions found in the `index` from the `Tree` to clean: +# ~~~rb +# tree_to_clean = Parser.parse_string(<<~RBI) +# class Foo +# def foo; end +# def bar; end +# end +# FOO = 10 +# BAR = 42 +# RBI +# +# cleaned_tree, operations = RemoveKnownDefinitions.remove(tree_to_clean, index) +# +# assert_equal(<<~RBI, cleaned_tree) +# class Foo +# def bar; end +# end +# BAR = 42 +# RBI +# +# assert_equal(<<~OPERATIONS, operations.join("\n")) +# Deleted ::Foo#foo at -:2:2-2-16 (duplicate from -:2:2-2:16) +# Deleted ::FOO at -:5:0-5:8 (duplicate from -:1:0-1:8) +# OPERATIONS +# ~~~ +# +# source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:48 +class RBI::Rewriters::RemoveKnownDefinitions < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:67 + sig { params(index: ::RBI::Index).void } + def initialize(index); end + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:64 + sig { returns(T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]) } + def operations; end + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:79 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:74 + sig { params(nodes: T::Array[::RBI::Node]).void } + def visit_all(nodes); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:107 + sig { params(node: ::RBI::Node, previous: ::RBI::Node).returns(T::Boolean) } + def can_delete_node?(node, previous); end + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:125 + sig { params(node: ::RBI::Node, previous: ::RBI::Node).void } + def delete_node(node, previous); end + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:98 + sig { params(node: ::RBI::Indexable).returns(T.nilable(::RBI::Node)) } + def previous_definition_for(node); end + + class << self + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:57 + sig do + params( + tree: ::RBI::Tree, + index: ::RBI::Index + ).returns([::RBI::Tree, T::Array[::RBI::Rewriters::RemoveKnownDefinitions::Operation]]) + end + def remove(tree, index); end + end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:130 +class RBI::Rewriters::RemoveKnownDefinitions::Operation < ::T::Struct + const :deleted_node, ::RBI::Node + const :duplicate_of, ::RBI::Node + + # source://rbi-0.0.15/lib/rbi/rewriters/remove_known_definitions.rb:137 + sig { returns(::String) } + def to_s; end + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:6 +class RBI::Rewriters::SortNodes < ::RBI::Visitor + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:10 + sig { override.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:61 + sig { params(kind: ::RBI::Group::Kind).returns(::Integer) } + def group_rank(kind); end + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:82 + sig { params(node: ::RBI::Node).returns(T.nilable(::String)) } + def node_name(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:33 + sig { params(node: ::RBI::Node).returns(::Integer) } + def node_rank(node); end + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:92 + sig { params(node: ::RBI::Node).void } + def sort_node_names!(node); end +end + +# Scopes +# +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:172 +class RBI::Scope < ::RBI::Tree + include ::RBI::Indexable + + abstract! + + # source://sorbet-runtime-0.5.10346/lib/types/private/abstract/declare.rb:37 + def initialize(*args, &blk); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:240 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # Duplicate `self` scope without its body + # + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:350 + sig { returns(T.self_type) } + def dup_empty; end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/model.rb:178 + sig { abstract.returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/index.rb:89 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:254 + sig { params(v: ::RBI::Printer).void } + def print_body(v); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/printer.rb:251 + sig { abstract.params(v: ::RBI::Printer).void } + def print_header(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:181 + sig { override.returns(::String) } + def to_s; end +end + +# A conflict between two scope headers +# +# Is rendered as a merge conflict between `left` and` right` for scope definitions: +# ~~~rb +# <<<<<<< left +# class Foo +# ======= +# module Foo +# >>>>>>> right +# def m1; end +# end +# ~~~ +# +# source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:617 +class RBI::ScopeConflict < ::RBI::Tree + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:631 + sig { params(left: ::RBI::Scope, right: ::RBI::Scope, left_name: ::String, right_name: ::String).void } + def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:640 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:621 + sig { returns(::RBI::Scope) } + def left; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:656 + sig { override.returns(T::Boolean) } + def oneline?; end + + # @return [Scope] + # + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:621 + def right; end +end + +# Sends +# +# source://rbi-0.0.15/lib/rbi/model.rb:919 +class RBI::Send < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:937 + sig do + params( + method: ::String, + args: T::Array[::RBI::Arg], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Send).void) + ).void + end + def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:945 + sig { params(arg: ::RBI::Arg).void } + def <<(arg); end + + # source://rbi-0.0.15/lib/rbi/model.rb:950 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:590 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:926 + sig { returns(T::Array[::RBI::Arg]) } + def args; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:519 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/index.rb:179 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:923 + sig { returns(::String) } + def method; end + + # source://rbi-0.0.15/lib/rbi/model.rb:955 + sig { returns(::String) } + def to_s; end +end + +# Sorbet's sigs +# +# source://rbi-0.0.15/lib/rbi/model.rb:1019 +class RBI::Sig < ::RBI::Node + # source://rbi-0.0.15/lib/rbi/model.rb:1051 + sig do + params( + params: T::Array[::RBI::SigParam], + return_type: T.nilable(::String), + is_abstract: T::Boolean, + is_override: T::Boolean, + is_overridable: T::Boolean, + is_final: T::Boolean, + type_params: T::Array[::String], + checked: T.nilable(::Symbol), + loc: T.nilable(::RBI::Loc), + block: T.nilable(T.proc.params(node: ::RBI::Sig).void) + ).void + end + def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1076 + sig { params(param: ::RBI::SigParam).void } + def <<(param); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1081 + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:631 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1035 + sig { returns(T.nilable(::Symbol)) } + def checked; end + + # @return [Symbol, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1035 + def checked=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:654 + sig { returns(T::Boolean) } + def inline_params?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + sig { returns(T::Boolean) } + def is_abstract; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_abstract=(_arg0); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_final; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_final=(_arg0); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_overridable; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_overridable=(_arg0); end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_override; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1029 + def is_override=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:649 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1023 + sig { returns(T::Array[::RBI::SigParam]) } + def params; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1026 + sig { returns(T.nilable(::String)) } + def return_type; end + + # @return [String, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1026 + def return_type=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1032 + sig { returns(T::Array[::String]) } + def type_params; end + + private + + # source://rbi-0.0.15/lib/rbi/printer.rb:696 + sig { params(v: ::RBI::Printer).void } + def print_as_block(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:672 + sig { params(v: ::RBI::Printer).void } + def print_as_line(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:661 + sig { returns(T::Array[::String]) } + def sig_modifiers; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:635 +class RBI::SigBuilder < ::RBI::ASTVisitor + # source://rbi-0.0.15/lib/rbi/parser.rb:649 + sig { void } + def initialize; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:646 + sig { returns(::RBI::Sig) } + def current; end + + # @return [Sig] + # + # source://rbi-0.0.15/lib/rbi/parser.rb:646 + def current=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:655 + sig { override.params(node: T.nilable(::AST::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:664 + sig { params(node: ::AST::Node).void } + def visit_send(node); end + + class << self + # source://rbi-0.0.15/lib/rbi/parser.rb:639 + sig { params(node: ::AST::Node).returns(::RBI::Sig) } + def build(node); end + end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1089 +class RBI::SigParam < ::RBI::NodeWithComments + # source://rbi-0.0.15/lib/rbi/model.rb:1104 + sig do + params( + name: ::String, + type: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::SigParam).void) + ).void + end + def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1112 + sig { params(other: ::Object).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:749 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:762 + sig { returns(T::Array[::String]) } + def comments_lines; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1093 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:754 + sig { params(v: ::RBI::Printer, last: T::Boolean).void } + def print_comment_leading_space(v, last:); end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1093 + def type; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:245 +class RBI::SingletonClass < ::RBI::Scope + # source://rbi-0.0.15/lib/rbi/model.rb:255 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::SingletonClass).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:261 + sig { override.returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:319 + sig { override.params(v: ::RBI::Printer).void } + def print_header(v); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:266 +class RBI::Struct < ::RBI::Scope + # source://rbi-0.0.15/lib/rbi/model.rb:288 + sig do + params( + name: ::String, + members: T::Array[::Symbol], + keyword_init: T::Boolean, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(struct: ::RBI::Struct).void) + ).void + end + def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:388 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:297 + sig { override.returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:276 + sig { returns(T::Boolean) } + def keyword_init; end + + # @return [Boolean] + # + # source://rbi-0.0.15/lib/rbi/model.rb:276 + def keyword_init=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:273 + sig { returns(T::Array[::Symbol]) } + def members; end + + # @return [Array] + # + # source://rbi-0.0.15/lib/rbi/model.rb:273 + def members=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/model.rb:270 + sig { returns(::String) } + def name; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:270 + def name=(_arg0); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:298 + sig { override.params(v: ::RBI::Printer).void } + def print_header(v); end +end + +# Sorbet's T::Enum +# +# source://rbi-0.0.15/lib/rbi/model.rb:1230 +class RBI::TEnum < ::RBI::Class + # source://rbi-0.0.15/lib/rbi/model.rb:1241 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(klass: ::RBI::TEnum).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1247 +class RBI::TEnumBlock < ::RBI::NodeWithComments + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1261 + sig do + params( + names: T::Array[::String], + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::TEnumBlock).void) + ).void + end + def initialize(names = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1273 + sig { params(name: ::String).void } + def <<(name); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:793 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1268 + sig { returns(T::Boolean) } + def empty?; end + + # source://rbi-0.0.15/lib/rbi/index.rb:209 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:546 + sig { override.params(other: ::RBI::Node).void } + def merge_with(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1251 + sig { returns(T::Array[::String]) } + def names; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1278 + sig { override.returns(::String) } + def to_s; end +end + +# Sorbet's T::Struct +# +# source://rbi-0.0.15/lib/rbi/model.rb:1119 +class RBI::TStruct < ::RBI::Class + # source://rbi-0.0.15/lib/rbi/model.rb:1130 + sig do + params( + name: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(klass: ::RBI::TStruct).void) + ).void + end + def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1168 +class RBI::TStructConst < ::RBI::TStructField + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1181 + sig do + params( + name: ::String, + type: ::String, + default: T.nilable(::String), + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::TStructConst).void) + ).void + end + def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:537 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1187 + sig { override.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/index.rb:189 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1193 + sig { override.returns(::String) } + def to_s; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:1136 +class RBI::TStructField < ::RBI::NodeWithComments + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:1157 + sig do + params( + name: ::String, + type: ::String, + default: T.nilable(::String), + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment] + ).void + end + def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:771 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:528 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1146 + sig { returns(T.nilable(::String)) } + def default; end + + # @return [String, nil] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1146 + def default=(_arg0); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/model.rb:1165 + sig { abstract.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1143 + sig { returns(::String) } + def name; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1143 + def name=(_arg0); end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1143 + def type; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1143 + def type=(_arg0); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1198 +class RBI::TStructProp < ::RBI::TStructField + include ::RBI::Indexable + + # source://rbi-0.0.15/lib/rbi/model.rb:1211 + sig do + params( + name: ::String, + type: ::String, + default: T.nilable(::String), + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::TStructProp).void) + ).void + end + def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:559 + sig { override.params(other: ::RBI::Node).returns(T::Boolean) } + def compatible_with?(other); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1217 + sig { override.returns(T::Array[::String]) } + def fully_qualified_names; end + + # source://rbi-0.0.15/lib/rbi/index.rb:199 + sig { override.returns(T::Array[::String]) } + def index_ids; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1223 + sig { override.returns(::String) } + def to_s; end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:102 +class RBI::Tree < ::RBI::NodeWithComments + # source://rbi-0.0.15/lib/rbi/model.rb:115 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Tree).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:122 + sig { params(node: ::RBI::Node).void } + def <<(node); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:224 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:66 + sig { params(with_todo_comment: T::Boolean).void } + def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:48 + sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void } + def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:38 + sig do + params( + name: ::String, + superclass_name: T.nilable(::String), + block: T.nilable(T.proc.params(scope: ::RBI::Scope).void) + ).returns(::RBI::Scope) + end + def create_class(name, superclass_name: T.unsafe(nil), &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:45 + sig { params(name: ::String, value: ::String).void } + def create_constant(name, value:); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:55 + sig { params(name: ::String).void } + def create_extend(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:50 + sig { params(name: ::String).void } + def create_include(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:88 + sig do + params( + name: ::String, + parameters: T::Array[::RBI::TypedParam], + return_type: ::String, + class_method: T::Boolean, + visibility: ::RBI::Visibility + ).void + end + def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:60 + sig { params(name: ::String).void } + def create_mixes_in_class_methods(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:25 + sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) } + def create_module(name, &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:9 + sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void } + def create_path(constant, &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:74 + sig do + params( + name: ::String, + type: ::String, + variance: ::Symbol, + fixed: T.nilable(::String), + upper: T.nilable(::String), + lower: T.nilable(::String) + ).void + end + def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:40 + sig { params(annotation: ::String).void } + def deannotate!(annotation); end + + # source://rbi-0.0.15/lib/rbi/model.rb:128 + sig { returns(T::Boolean) } + def empty?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:38 + sig { void } + def group_nodes!; end + + # source://rbi-0.0.15/lib/rbi/index.rb:64 + sig { returns(::RBI::Index) } + def index; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:318 + sig do + params( + other: ::RBI::Tree, + left_name: ::String, + right_name: ::String, + keep: ::RBI::Rewriters::Merge::Keep + ).returns(::RBI::MergeTree) + end + def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:45 + sig { void } + def nest_non_public_methods!; end + + # source://rbi-0.0.15/lib/rbi/rewriters/nest_singleton_methods.rb:35 + sig { void } + def nest_singleton_methods!; end + + # source://rbi-0.0.15/lib/rbi/model.rb:106 + sig { returns(T::Array[::RBI::Node]) } + def nodes; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:231 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:105 + sig { void } + def sort_nodes!; end + + private + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:108 + sig { params(node: ::RBI::Node).returns(::RBI::Node) } + def create_node(node); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:103 + sig { returns(T::Hash[::String, ::RBI::Node]) } + def nodes_cache; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:156 +class RBI::TreeBuilder < ::RBI::ASTVisitor + # source://rbi-0.0.15/lib/rbi/parser.rb:172 + sig do + params( + file: ::String, + comments: T::Array[::Parser::Source::Comment], + nodes_comments_assoc: T::Hash[::Parser::Source::Map, T::Array[::Parser::Source::Comment]] + ).void + end + def initialize(file:, comments: T.unsafe(nil), nodes_comments_assoc: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:163 + sig { returns(T.nilable(::AST::Node)) } + def last_node; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:187 + sig { void } + def post_process; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:160 + sig { returns(::RBI::Tree) } + def tree; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:193 + sig { override.params(node: T.nilable(::Object)).void } + def visit(node); end + + private + + # source://rbi-0.0.15/lib/rbi/parser.rb:546 + sig { void } + def assoc_dangling_comments; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:527 + sig { returns(::RBI::Tree) } + def current_scope; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:532 + sig { returns(T::Array[::RBI::Sig]) } + def current_sigs; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:539 + sig { returns(T::Array[::RBI::Comment]) } + def current_sigs_comments; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:516 + sig { params(node: ::AST::Node).returns(T::Array[::RBI::Comment]) } + def node_comments(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:511 + sig { params(node: ::AST::Node).returns(::RBI::Loc) } + def node_loc(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:402 + sig { params(node: ::AST::Node).returns(T.nilable(::RBI::Node)) } + def parse_block(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:249 + sig { params(node: ::AST::Node).returns(::RBI::Node) } + def parse_const_assign(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:263 + sig { params(node: ::AST::Node).returns(::RBI::Method) } + def parse_def(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:486 + sig { params(node: ::AST::Node).returns(::RBI::TEnumBlock) } + def parse_enum(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:290 + sig { params(node: ::AST::Node).returns(::RBI::Param) } + def parse_param(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:503 + sig { params(node: ::AST::Node).returns(::RBI::RequiresAncestor) } + def parse_requires_ancestor(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:229 + sig { params(node: ::AST::Node).returns(::RBI::Scope) } + def parse_scope(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:318 + sig { params(node: ::AST::Node).returns(T.nilable(::RBI::Node)) } + def parse_send(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:385 + sig { params(node: ::AST::Node).returns(T::Array[::RBI::Arg]) } + def parse_send_args(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:479 + sig { params(node: ::AST::Node).returns(::RBI::Sig) } + def parse_sig(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:424 + sig { params(node: ::AST::Node).returns(::RBI::Struct) } + def parse_struct(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:463 + sig { params(node: ::AST::Node).returns([::String, ::String, T.nilable(::String)]) } + def parse_tstruct_prop(node); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:564 + sig { void } + def separate_header_comments; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:586 + sig { void } + def set_root_tree_loc; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:418 + sig { params(node: ::AST::Node).returns(T::Boolean) } + def struct_definition?(node); end +end + +# source://rbi-0.0.15/lib/rbi/model.rb:1311 +class RBI::TypeMember < ::RBI::NodeWithComments + # source://rbi-0.0.15/lib/rbi/model.rb:1326 + sig do + params( + name: ::String, + value: ::String, + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::TypeMember).void) + ).void + end + def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:810 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:1334 + sig { returns(::String) } + def fully_qualified_name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1315 + sig { returns(::String) } + def name; end + + # source://rbi-0.0.15/lib/rbi/model.rb:1340 + sig { override.returns(::String) } + def to_s; end + + # @return [String] + # + # source://rbi-0.0.15/lib/rbi/model.rb:1315 + def value; end +end + +# source://rbi-0.0.15/lib/rbi/parser.rb:20 +class RBI::UnexpectedParserError < ::StandardError + # source://rbi-0.0.15/lib/rbi/parser.rb:27 + sig { params(parent_exception: ::Exception, last_location: ::RBI::Loc).void } + def initialize(parent_exception, last_location); end + + # source://rbi-0.0.15/lib/rbi/parser.rb:24 + sig { returns(::RBI::Loc) } + def last_location; end + + # source://rbi-0.0.15/lib/rbi/parser.rb:34 + sig { params(io: T.any(::IO, ::StringIO)).void } + def print_debug(io: T.unsafe(nil)); end +end + +# source://rbi-0.0.15/lib/rbi/version.rb:5 +RBI::VERSION = T.let(T.unsafe(nil), String) + +# Visibility +# +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/model.rb:833 +class RBI::Visibility < ::RBI::NodeWithComments + abstract! + + # source://rbi-0.0.15/lib/rbi/model.rb:843 + sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T::Array[::RBI::Comment]).void } + def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/model.rb:849 + sig { params(other: ::RBI::Visibility).returns(T::Boolean) } + def ==(other); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:577 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/model.rb:864 + sig { returns(T::Boolean) } + def private?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:859 + sig { returns(T::Boolean) } + def protected?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:854 + sig { returns(T::Boolean) } + def public?; end + + # source://rbi-0.0.15/lib/rbi/model.rb:840 + sig { returns(::Symbol) } + def visibility; end +end + +# source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:51 +class RBI::VisibilityGroup < ::RBI::Tree + # source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:58 + sig { params(visibility: ::RBI::Visibility).void } + def initialize(visibility); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:846 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:859 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:55 + sig { returns(::RBI::Visibility) } + def visibility; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://rbi-0.0.15/lib/rbi/visitor.rb:5 +class RBI::Visitor + abstract! + + # source://sorbet-runtime-0.5.10346/lib/types/private/abstract/declare.rb:37 + def initialize(*args, &blk); end + + # @abstract + # + # source://rbi-0.0.15/lib/rbi/visitor.rb:12 + sig { abstract.params(node: T.nilable(::RBI::Node)).void } + def visit(node); end + + # source://rbi-0.0.15/lib/rbi/visitor.rb:15 + sig { params(nodes: T::Array[::RBI::Node]).void } + def visit_all(nodes); end +end diff --git a/sorbet/rbi/gems/redcarpet.rbi b/sorbet/rbi/gems/redcarpet.rbi deleted file mode 100644 index 354e9062..00000000 --- a/sorbet/rbi/gems/redcarpet.rbi +++ /dev/null @@ -1,84 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/redcarpet/all/redcarpet.rbi -# -# redcarpet-3.5.1 - -class Redcarpet::Markdown - def render(arg0); end - def renderer; end - def self.new(*arg0); end -end -class Redcarpet::Render::Base - def initialize; end -end -class Redcarpet::Render::HTML < Redcarpet::Render::Base - def initialize(*arg0); end -end -class Redcarpet::Render::HTML_TOC < Redcarpet::Render::Base - def initialize(*arg0); end -end -module Redcarpet::Render::SmartyPants - def postprocess(arg0); end - def self.render(text); end - extend Redcarpet::Render::SmartyPants -end -class RedcarpetCompat - def initialize(text, *exts); end - def list_to_truthy_hash(list); end - def parse_extensions_and_renderer_options(exts); end - def rename_extensions(exts); end - def text; end - def text=(arg0); end - def to_html(*_dummy); end -end -module Redcarpet -end -module Redcarpet::Render -end -class Redcarpet::Render::XHTML < Redcarpet::Render::HTML - def initialize(extensions = nil); end -end -class Redcarpet::Render::SmartyHTML < Redcarpet::Render::HTML - include Redcarpet::Render::SmartyPants -end -class Redcarpet::Render::Safe < Redcarpet::Render::HTML - def block_code(code, lang); end - def html_escape(string); end - def initialize(extensions = nil); end -end -class Redcarpet::Render::StripDown < Redcarpet::Render::Base - def autolink(*args); end - def block_code(*args); end - def block_html(*args); end - def block_quote(*args); end - def codespan(*args); end - def double_emphasis(*args); end - def emphasis(*args); end - def entity(*args); end - def footnote_def(*args); end - def footnote_ref(*args); end - def footnotes(*args); end - def header(text, header_level); end - def highlight(*args); end - def image(link, title, content); end - def link(link, title, content); end - def list(*args); end - def list_item(*args); end - def normal_text(*args); end - def paragraph(text); end - def quote(*args); end - def raw_html(*args); end - def strikethrough(*args); end - def superscript(*args); end - def table(header, body); end - def table_cell(content, alignment); end - def table_row(content); end - def triple_emphasis(*args); end - def underline(*args); end -end diff --git a/sorbet/rbi/gems/redcarpet@3.5.1.rbi b/sorbet/rbi/gems/redcarpet@3.5.1.rbi new file mode 100644 index 00000000..14530d16 --- /dev/null +++ b/sorbet/rbi/gems/redcarpet@3.5.1.rbi @@ -0,0 +1,169 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `redcarpet` gem. +# Please instead update this file by running `bin/tapioca gem redcarpet`. + +# source://redcarpet-3.5.1/lib/redcarpet/compat.rb:71 +Markdown = RedcarpetCompat + +# source://redcarpet-3.5.1/lib/redcarpet.rb:4 +module Redcarpet; end + +# source://redcarpet-3.5.1/lib/redcarpet.rb:7 +class Redcarpet::Markdown + def render(_arg0); end + + # Returns the value of attribute renderer. + # + # source://redcarpet-3.5.1/lib/redcarpet.rb:8 + def renderer; end + + class << self + def new(*_arg0); end + end +end + +# source://redcarpet-3.5.1/lib/redcarpet.rb:11 +module Redcarpet::Render; end + +class Redcarpet::Render::Base + def initialize; end +end + +class Redcarpet::Render::HTML < ::Redcarpet::Render::Base + def initialize(*_arg0); end +end + +class Redcarpet::Render::HTML_TOC < ::Redcarpet::Render::Base + def initialize(*_arg0); end +end + +# A renderer object you can use to deal with users' input. It +# enables +escape_html+ and +safe_links_only+ by default. +# +# The +block_code+ callback is also overriden not to include +# the lang's class as the user can basically specify anything +# with the vanilla one. +# +# source://redcarpet-3.5.1/lib/redcarpet.rb:31 +class Redcarpet::Render::Safe < ::Redcarpet::Render::HTML + # @return [Safe] a new instance of Safe + # + # source://redcarpet-3.5.1/lib/redcarpet.rb:32 + def initialize(extensions = T.unsafe(nil)); end + + # source://redcarpet-3.5.1/lib/redcarpet.rb:39 + def block_code(code, lang); end + + private + + # TODO: This is far from ideal to have such method as we + # are duplicating existing code from Houdini. This method + # should be defined at the C level. + # + # source://redcarpet-3.5.1/lib/redcarpet.rb:50 + def html_escape(string); end +end + +# HTML + SmartyPants renderer +# +# source://redcarpet-3.5.1/lib/redcarpet.rb:21 +class Redcarpet::Render::SmartyHTML < ::Redcarpet::Render::HTML + include ::Redcarpet::Render::SmartyPants +end + +# SmartyPants Mixin module +# +# Implements SmartyPants.postprocess, which +# performs smartypants replacements on the HTML file, +# once it has been fully rendered. +# +# To add SmartyPants postprocessing to your custom +# renderers, just mixin the module `include SmartyPants` +# +# You can also use this as a standalone SmartyPants +# implementation. +# +# Example: +# +# # Mixin +# class CoolRenderer < HTML +# include SmartyPants +# # more code here +# end +# +# # Standalone +# Redcarpet::Render::SmartyPants.render("you're") +# +# source://redcarpet-3.5.1/lib/redcarpet.rb:85 +module Redcarpet::Render::SmartyPants + extend ::Redcarpet::Render::SmartyPants + + def postprocess(_arg0); end + + class << self + # source://redcarpet-3.5.1/lib/redcarpet.rb:87 + def render(text); end + end +end + +# XHTML Renderer +# +# source://redcarpet-3.5.1/lib/redcarpet.rb:14 +class Redcarpet::Render::XHTML < ::Redcarpet::Render::HTML + # @return [XHTML] a new instance of XHTML + # + # source://redcarpet-3.5.1/lib/redcarpet.rb:15 + def initialize(extensions = T.unsafe(nil)); end +end + +# source://redcarpet-3.5.1/lib/redcarpet.rb:5 +Redcarpet::VERSION = T.let(T.unsafe(nil), String) + +# Creates an instance of Redcarpet with the RedCloth API. +# +# source://redcarpet-3.5.1/lib/redcarpet/compat.rb:2 +class RedcarpetCompat + # @return [RedcarpetCompat] a new instance of RedcarpetCompat + # + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:5 + def initialize(text, *exts); end + + # Returns the value of attribute text. + # + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:3 + def text; end + + # Sets the attribute text + # + # @param value the value to set the attribute text to. + # + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:3 + def text=(_arg0); end + + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:12 + def to_html(*_dummy); end + + private + + # Turns a list of symbols into a hash of symbol => true. + # + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:66 + def list_to_truthy_hash(list); end + + # Returns two hashes, the extensions and renderer options + # given the extension list + # + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:59 + def parse_extensions_and_renderer_options(exts); end + + # source://redcarpet-3.5.1/lib/redcarpet/compat.rb:47 + def rename_extensions(exts); end +end + +# source://redcarpet-3.5.1/lib/redcarpet/compat.rb:18 +RedcarpetCompat::EXTENSION_MAP = T.let(T.unsafe(nil), Hash) + +# source://redcarpet-3.5.1/lib/redcarpet/compat.rb:44 +RedcarpetCompat::RENDERER_OPTIONS = T.let(T.unsafe(nil), Array) diff --git a/sorbet/rbi/gems/regexp_parser.rbi b/sorbet/rbi/gems/regexp_parser.rbi deleted file mode 100644 index dfe118a9..00000000 --- a/sorbet/rbi/gems/regexp_parser.rbi +++ /dev/null @@ -1,947 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/regexp_parser/all/regexp_parser.rbi -# -# regexp_parser-2.5.0 - -class Regexp -end -class Regexp::Parser - def active_opts; end - def anchor(token); end - def assign_effective_number(exp); end - def assign_referenced_expressions; end - def backref(token); end - def captured_group_count_at_level; end - def captured_group_counts; end - def captured_group_counts=(arg0); end - def close_completed_character_set_range; end - def close_group; end - def close_set; end - def conditional(token); end - def conditional_nesting; end - def conditional_nesting=(arg0); end - def count_captured_group; end - def decrease_nesting; end - def escape(token); end - def extract_options(input, options); end - def free_space(token); end - def group(token); end - def increase_group_level(exp); end - def intersection(token); end - def keep(token); end - def literal(token); end - def meta(token); end - def negate_set; end - def nest(exp); end - def nest_conditional(exp); end - def nesting; end - def nesting=(arg0); end - def node; end - def node=(arg0); end - def open_group(token); end - def open_set(token); end - def options_group(token); end - def options_stack; end - def options_stack=(arg0); end - def parse(input, syntax = nil, options: nil, &block); end - def parse_token(token); end - def posixclass(token); end - def property(token); end - def quantifier(token); end - def range(token); end - def root; end - def root=(arg0); end - def self.parse(input, syntax = nil, options: nil, &block); end - def sequence_operation(klass, token); end - def set(token); end - def switching_options; end - def switching_options=(arg0); end - def total_captured_group_count; end - def type(token); end - include Regexp::Expression - include Regexp::Expression::UnicodeProperty -end -class Regexp::Token < Struct - def conditional_level; end - def conditional_level=(_); end - def length; end - def level; end - def level=(_); end - def next; end - def next=(arg0); end - def offset; end - def previous; end - def previous=(arg0); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def set_level; end - def set_level=(_); end - def te; end - def te=(_); end - def text; end - def text=(_); end - def token; end - def token=(_); end - def ts; end - def ts=(_); end - def type; end - def type=(_); end -end -class Regexp::Parser::Error < StandardError -end -class Regexp::Scanner - def append_literal(data, ts, te); end - def block; end - def block=(arg0); end - def char_pos; end - def char_pos=(arg0); end - def conditional_stack; end - def conditional_stack=(arg0); end - def copy(data, ts, te); end - def emit(type, token, text); end - def emit_literal; end - def emit_meta_control_sequence(data, ts, te, token); end - def emit_options(text); end - def free_spacing; end - def free_spacing=(arg0); end - def free_spacing?(input_object, options); end - def group_depth; end - def group_depth=(arg0); end - def in_group?; end - def in_set?; end - def literal; end - def literal=(arg0); end - def scan(input_object, options: nil, &block); end - def self.long_prop_map; end - def self.parse_prop_map(name); end - def self.posix_classes; end - def self.scan(input_object, options: nil, &block); end - def self.short_prop_map; end - def set_depth; end - def set_depth=(arg0); end - def spacing_stack; end - def spacing_stack=(arg0); end - def tokens; end - def tokens=(arg0); end - def validation_error(type, what, reason = nil); end -end -class Regexp::Scanner::ScannerError < Regexp::Parser::Error -end -class Regexp::Scanner::ValidationError < Regexp::Parser::Error - def initialize(reason); end -end -class Regexp::Scanner::PrematureEndError < Regexp::Scanner::ScannerError - def initialize(where = nil); end -end -class Regexp::Scanner::InvalidSequenceError < Regexp::Scanner::ValidationError - def initialize(what = nil, where = nil); end -end -class Regexp::Scanner::InvalidGroupError < Regexp::Scanner::ValidationError - def initialize(what, reason); end -end -class Regexp::Scanner::InvalidGroupOption < Regexp::Scanner::ValidationError - def initialize(option, text); end -end -class Regexp::Scanner::InvalidBackrefError < Regexp::Scanner::ValidationError - def initialize(what, reason); end -end -class Regexp::Scanner::UnknownUnicodePropertyError < Regexp::Scanner::ValidationError - def initialize(name); end -end -class Regexp::Scanner::UnknownPosixClassError < Regexp::Scanner::ValidationError - def initialize(text); end -end -module Regexp::Syntax - def comparable(name); end - def const_missing(const_name); end - def fallback_version_class(version); end - def for(name); end - def new(name); end - def self.comparable(name); end - def self.const_missing(const_name); end - def self.fallback_version_class(version); end - def self.for(name); end - def self.new(name); end - def self.specified_versions; end - def self.supported?(name); end - def self.version_class(version); end - def self.warn_if_future_version(const_name); end - def specified_versions; end - def supported?(name); end - def version_class(version); end - def warn_if_future_version(const_name); end -end -module Regexp::Syntax::Token -end -module Regexp::Syntax::Token::Anchor -end -module Regexp::Syntax::Token::Assertion -end -module Regexp::Syntax::Token::Backreference -end -module Regexp::Syntax::Token::SubexpressionCall -end -module Regexp::Syntax::Token::PosixClass -end -module Regexp::Syntax::Token::CharacterSet -end -module Regexp::Syntax::Token::CharacterType -end -module Regexp::Syntax::Token::Conditional -end -module Regexp::Syntax::Token::Escape -end -module Regexp::Syntax::Token::Group -end -module Regexp::Syntax::Token::Keep -end -module Regexp::Syntax::Token::Meta -end -module Regexp::Syntax::Token::Quantifier -end -module Regexp::Syntax::Token::UnicodeProperty -end -module Regexp::Syntax::Token::UnicodeProperty::Category -end -module Regexp::Syntax::Token::Literal -end -module Regexp::Syntax::Token::FreeSpace -end -class Regexp::Syntax::NotImplementedError < Regexp::Syntax::SyntaxError - def initialize(syntax, type, token); end -end -class Regexp::Syntax::Base - def initialize; end - def method_missing(name, *args); end - def respond_to_missing?(name, include_private = nil); end - def self.added_features; end - def self.check!(type, token); end - def self.check?(type, token); end - def self.excludes(type, tokens); end - def self.features; end - def self.features=(arg0); end - def self.implementations(type); end - def self.implements!(type, token); end - def self.implements(type, tokens); end - def self.implements?(type, token); end - def self.inherited(subclass); end - def self.normalize(type, token); end - def self.normalize_backref(type, token); end - def self.normalize_group(type, token); end - def self.removed_features; end - include Regexp::Syntax::Token -end -class Regexp::Syntax::Any < Regexp::Syntax::Base - def self.implements?(_type, _token); end -end -class Regexp::Syntax::InvalidVersionNameError < Regexp::Syntax::SyntaxError - def initialize(name); end -end -class Regexp::Syntax::UnknownSyntaxNameError < Regexp::Syntax::SyntaxError - def initialize(name); end -end -class Regexp::Syntax::V1_8_6 < Regexp::Syntax::Base -end -class Regexp::Syntax::V1_9_1 < Regexp::Syntax::V1_8_6 -end -class Regexp::Syntax::V1_9_3 < Regexp::Syntax::V1_9_1 -end -class Regexp::Syntax::V2_0_0 < Regexp::Syntax::V1_9_3 -end -class Regexp::Syntax::V2_2_0 < Regexp::Syntax::V2_0_0 -end -class Regexp::Syntax::V2_3_0 < Regexp::Syntax::V2_2_0 -end -class Regexp::Syntax::V2_4_0 < Regexp::Syntax::V2_3_0 -end -class Regexp::Syntax::V2_4_1 < Regexp::Syntax::V2_4_0 -end -class Regexp::Syntax::V2_5_0 < Regexp::Syntax::V2_4_1 -end -class Regexp::Syntax::V2_6_0 < Regexp::Syntax::V2_5_0 -end -class Regexp::Syntax::V2_6_2 < Regexp::Syntax::V2_6_0 -end -class Regexp::Syntax::V2_6_3 < Regexp::Syntax::V2_6_2 -end -class Regexp::Syntax::V3_1_0 < Regexp::Syntax::V2_6_3 -end -class Regexp::Syntax::V3_2_0 < Regexp::Syntax::V3_1_0 -end -class Regexp::Syntax::SyntaxError < Regexp::Parser::Error -end -class Regexp::Lexer - def ascend(type, token); end - def break_codepoint_list(token); end - def break_literal(token); end - def conditional_nesting; end - def conditional_nesting=(arg0); end - def descend(type, token); end - def lex(input, syntax = nil, options: nil, &block); end - def merge_condition(current); end - def nesting; end - def nesting=(arg0); end - def self.lex(input, syntax = nil, options: nil, &block); end - def self.scan(input, syntax = nil, options: nil, &block); end - def set_nesting; end - def set_nesting=(arg0); end - def shift; end - def shift=(arg0); end - def tokens; end - def tokens=(arg0); end -end -module Regexp::Expression -end -module Regexp::Expression::Shared - def ==(other); end - def ===(other); end - def base_length; end - def coded_offset; end - def eql?(other); end - def full_length; end - def init_from_token_and_options(token, options = nil); end - def initialize_copy(orig); end - def is?(test_token, test_type = nil); end - def nesting_level=(lvl); end - def offset; end - def one_of?(scope, top = nil); end - def parts; end - def quantified?; end - def quantifier_affix(expression_format); end - def self.included(mod); end - def starts_at; end - def terminal?; end - def to_s(format = nil); end - def to_str(format = nil); end - def token_class; end - def type?(test_type); end -end -module Regexp::Expression::Shared::ClassMethods - def construct(params = nil); end - def construct_defaults; end - def token_class; end -end -class Regexp::Expression::Base - def =~(string, offset = nil); end - def a?; end - def ascii_classes?; end - def attributes; end - def case_insensitive?; end - def conditional_level; end - def conditional_level=(arg0); end - def d?; end - def default_classes?; end - def extended?; end - def free_spacing?; end - def greedy?; end - def i?; end - def ignore_case?; end - def initialize(token, options = nil); end - def initialize_copy(orig); end - def lazy?; end - def level; end - def level=(arg0); end - def m?; end - def match(string, offset = nil); end - def match?(string); end - def matches?(string); end - def multiline?; end - def nesting_level; end - def options; end - def options=(arg0); end - def possessive?; end - def quantifier; end - def quantifier=(arg0); end - def quantify(*args); end - def quantity; end - def reluctant?; end - def repetitions; end - def set_level; end - def set_level=(arg0); end - def strfre(format = nil, indent_offset = nil, index = nil); end - def strfregexp(format = nil, indent_offset = nil, index = nil); end - def te; end - def te=(arg0); end - def text; end - def text=(arg0); end - def to_h; end - def to_re(format = nil); end - def token; end - def token=(arg0); end - def ts; end - def ts=(arg0); end - def type; end - def type=(arg0); end - def u?; end - def unicode_classes?; end - def unquantified_clone; end - def x?; end - extend Regexp::Expression::Shared::ClassMethods - include Regexp::Expression::Shared -end -class Regexp::Expression::Quantifier - def conditional_level; end - def conditional_level=(arg0); end - def deprecated_old_init(token, text, min, max, mode = nil); end - def greedy?; end - def initialize(*args); end - def lazy?; end - def level; end - def level=(arg0); end - def max; end - def min; end - def minmax; end - def mode; end - def nesting_level; end - def options; end - def options=(arg0); end - def possessive?; end - def quantifier; end - def quantifier=(arg0); end - def reluctant?; end - def set_level; end - def set_level=(arg0); end - def te; end - def te=(arg0); end - def text; end - def text=(arg0); end - def to_h; end - def token; end - def token=(arg0); end - def ts; end - def ts=(arg0); end - def type; end - def type=(arg0); end - extend Regexp::Expression::Shared::ClassMethods - include Regexp::Expression::Shared -end -class Regexp::Expression::Subexpression < Regexp::Expression::Base - def <<(exp); end - def [](*args, &block); end - def at(*args, &block); end - def dig(*indices); end - def each(*args, &block); end - def each_expression(include_self = nil); end - def empty?(*args, &block); end - def expressions; end - def expressions=(arg0); end - def fetch(*args, &block); end - def flat_map(include_self = nil); end - def index(*args, &block); end - def initialize(token, options = nil); end - def initialize_copy(orig); end - def inner_match_length; end - def intersperse(expressions, separator); end - def join(*args, &block); end - def last(*args, &block); end - def length(*args, &block); end - def match_length; end - def parts; end - def strfre_tree(format = nil, include_self = nil, separator = nil); end - def strfregexp_tree(format = nil, include_self = nil, separator = nil); end - def te; end - def to_h; end - def traverse(include_self = nil, &block); end - def values_at(*args, &block); end - def walk(include_self = nil, &block); end - include Enumerable -end -class Regexp::Expression::Sequence < Regexp::Expression::Subexpression - def quantify(*args); end - def self.add_to(exp, params = nil, active_opts = nil); end - def starts_at; end - def ts; end -end -class Regexp::Expression::SequenceOperation < Regexp::Expression::Subexpression - def <<(exp); end - def add_sequence(active_opts = nil); end - def operands; end - def operator; end - def parts; end - def sequences; end - def starts_at; end - def ts; end -end -class Regexp::Expression::Alternative < Regexp::Expression::Sequence -end -class Regexp::Expression::Alternation < Regexp::Expression::SequenceOperation - def alternatives; end - def match_length; end -end -module Regexp::Expression::Anchor -end -class Regexp::Expression::Anchor::Base < Regexp::Expression::Base - def match_length; end -end -class Regexp::Expression::Anchor::BeginningOfLine < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::EndOfLine < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::BeginningOfString < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::EndOfString < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::WordBoundary < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::NonWordBoundary < Regexp::Expression::Anchor::Base -end -class Regexp::Expression::Anchor::MatchStart < Regexp::Expression::Anchor::Base -end -module Regexp::Expression::Backreference -end -class Regexp::Expression::Backreference::Base < Regexp::Expression::Base - def initialize_copy(orig); end - def match_length; end - def referenced_expression; end - def referenced_expression=(arg0); end -end -class Regexp::Expression::Backreference::Number < Regexp::Expression::Backreference::Base - def initialize(token, options = nil); end - def number; end - def reference; end -end -class Regexp::Expression::Backreference::Name < Regexp::Expression::Backreference::Base - def initialize(token, options = nil); end - def name; end - def reference; end -end -class Regexp::Expression::Backreference::NumberRelative < Regexp::Expression::Backreference::Number - def effective_number; end - def effective_number=(arg0); end - def reference; end -end -class Regexp::Expression::Backreference::NumberCall < Regexp::Expression::Backreference::Number -end -class Regexp::Expression::Backreference::NameCall < Regexp::Expression::Backreference::Name -end -class Regexp::Expression::Backreference::NumberCallRelative < Regexp::Expression::Backreference::NumberRelative -end -class Regexp::Expression::Backreference::NumberRecursionLevel < Regexp::Expression::Backreference::Number - def initialize(token, options = nil); end - def recursion_level; end -end -class Regexp::Expression::Backreference::NameRecursionLevel < Regexp::Expression::Backreference::Name - def initialize(token, options = nil); end - def recursion_level; end -end -class Regexp::Expression::CharacterSet < Regexp::Expression::Subexpression - def close; end - def closed; end - def closed=(arg0); end - def closed?; end - def initialize(token, options = nil); end - def match_length; end - def negate; end - def negated?; end - def negative; end - def negative=(arg0); end - def negative?; end - def parts; end -end -class Regexp::Expression::CharacterSet::IntersectedSequence < Regexp::Expression::Sequence - def match_length; end -end -class Regexp::Expression::CharacterSet::Intersection < Regexp::Expression::SequenceOperation - def match_length; end -end -class Regexp::Expression::CharacterSet::Range < Regexp::Expression::Subexpression - def <<(exp); end - def complete?; end - def match_length; end - def parts; end - def starts_at; end - def ts; end -end -module Regexp::Expression::CharacterType -end -class Regexp::Expression::CharacterType::Base < Regexp::Expression::Base - def match_length; end -end -class Regexp::Expression::CharacterType::Any < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::Digit < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::NonDigit < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::Hex < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::NonHex < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::Word < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::NonWord < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::Space < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::NonSpace < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::Linebreak < Regexp::Expression::CharacterType::Base -end -class Regexp::Expression::CharacterType::ExtendedGrapheme < Regexp::Expression::CharacterType::Base -end -module Regexp::Expression::Conditional -end -class Regexp::Expression::Conditional::TooManyBranches < Regexp::Parser::Error - def initialize; end -end -class Regexp::Expression::Conditional::Condition < Regexp::Expression::Base - def initialize_copy(orig); end - def match_length; end - def reference; end - def referenced_expression; end - def referenced_expression=(arg0); end -end -class Regexp::Expression::Conditional::Branch < Regexp::Expression::Sequence -end -class Regexp::Expression::Conditional::Expression < Regexp::Expression::Subexpression - def <<(exp); end - def add_sequence(active_opts = nil); end - def branch(active_opts = nil); end - def branches; end - def condition; end - def condition=(exp); end - def initialize_copy(orig); end - def match_length; end - def parts; end - def reference; end - def referenced_expression; end - def referenced_expression=(arg0); end -end -module Regexp::Expression::EscapeSequence -end -class Regexp::Expression::EscapeSequence::Base < Regexp::Expression::Base - def char; end - def codepoint; end - def match_length; end -end -class Regexp::Expression::EscapeSequence::Literal < Regexp::Expression::EscapeSequence::Base - def char; end -end -class Regexp::Expression::EscapeSequence::AsciiEscape < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Backspace < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Bell < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::FormFeed < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Newline < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Return < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Tab < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::VerticalTab < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Hex < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::Codepoint < Regexp::Expression::EscapeSequence::Base -end -class Regexp::Expression::EscapeSequence::CodepointList < Regexp::Expression::EscapeSequence::Base - def char; end - def chars; end - def codepoint; end - def codepoints; end - def match_length; end -end -class Regexp::Expression::EscapeSequence::Octal < Regexp::Expression::EscapeSequence::Base - def char; end -end -class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < Regexp::Expression::EscapeSequence::Base - def char; end - def control_sequence_to_s(control_sequence); end - def meta_char_to_codepoint(meta_char); end -end -class Regexp::Expression::EscapeSequence::Control < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - def codepoint; end -end -class Regexp::Expression::EscapeSequence::Meta < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - def codepoint; end -end -class Regexp::Expression::EscapeSequence::MetaControl < Regexp::Expression::EscapeSequence::AbstractMetaControlSequence - def codepoint; end -end -class Regexp::Expression::FreeSpace < Regexp::Expression::Base - def match_length; end - def quantify(*_args); end -end -class Regexp::Expression::Comment < Regexp::Expression::FreeSpace -end -class Regexp::Expression::WhiteSpace < Regexp::Expression::FreeSpace - def merge(exp); end -end -module Regexp::Expression::Group -end -class Regexp::Expression::Group::Base < Regexp::Expression::Subexpression - def capturing?; end - def comment?; end - def parts; end -end -class Regexp::Expression::Group::Passive < Regexp::Expression::Group::Base - def implicit=(arg0); end - def implicit?; end - def initialize(*arg0); end - def parts; end -end -class Regexp::Expression::Group::Absence < Regexp::Expression::Group::Base - def match_length; end -end -class Regexp::Expression::Group::Atomic < Regexp::Expression::Group::Base -end -class Regexp::Expression::Group::Options < Regexp::Expression::Group::Base - def initialize_copy(orig); end - def option_changes; end - def option_changes=(arg0); end -end -class Regexp::Expression::Group::Capture < Regexp::Expression::Group::Base - def capturing?; end - def identifier; end - def number; end - def number=(arg0); end - def number_at_level; end - def number_at_level=(arg0); end -end -class Regexp::Expression::Group::Named < Regexp::Expression::Group::Capture - def identifier; end - def initialize(token, options = nil); end - def initialize_copy(orig); end - def name; end -end -class Regexp::Expression::Group::Comment < Regexp::Expression::Group::Base - def comment?; end - def parts; end -end -module Regexp::Expression::Assertion -end -class Regexp::Expression::Assertion::Base < Regexp::Expression::Group::Base - def match_length; end -end -class Regexp::Expression::Assertion::Lookahead < Regexp::Expression::Assertion::Base -end -class Regexp::Expression::Assertion::NegativeLookahead < Regexp::Expression::Assertion::Base -end -class Regexp::Expression::Assertion::Lookbehind < Regexp::Expression::Assertion::Base -end -class Regexp::Expression::Assertion::NegativeLookbehind < Regexp::Expression::Assertion::Base -end -module Regexp::Expression::Keep -end -class Regexp::Expression::Keep::Mark < Regexp::Expression::Base - def match_length; end -end -class Regexp::Expression::Literal < Regexp::Expression::Base - def match_length; end -end -class Regexp::Expression::PosixClass < Regexp::Expression::Base - def match_length; end - def name; end - def negative?; end -end -class Regexp::Expression::Root < Regexp::Expression::Subexpression - def self.build(options = nil); end -end -module Regexp::Expression::UnicodeProperty -end -class Regexp::Expression::UnicodeProperty::Base < Regexp::Expression::Base - def match_length; end - def name; end - def negative?; end - def shortcut; end -end -class Regexp::Expression::UnicodeProperty::Alnum < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Alpha < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Ascii < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Blank < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Cntrl < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Digit < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Graph < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Lower < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Print < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Punct < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Space < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Upper < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Word < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Xdigit < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::XPosixPunct < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Newline < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Any < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Assigned < Regexp::Expression::UnicodeProperty::Base -end -module Regexp::Expression::UnicodeProperty::Letter -end -class Regexp::Expression::UnicodeProperty::Letter::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Any < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Cased < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Uppercase < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Lowercase < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Titlecase < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Modifier < Regexp::Expression::UnicodeProperty::Letter::Base -end -class Regexp::Expression::UnicodeProperty::Letter::Other < Regexp::Expression::UnicodeProperty::Letter::Base -end -module Regexp::Expression::UnicodeProperty::Mark -end -class Regexp::Expression::UnicodeProperty::Mark::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Mark::Any < Regexp::Expression::UnicodeProperty::Mark::Base -end -class Regexp::Expression::UnicodeProperty::Mark::Combining < Regexp::Expression::UnicodeProperty::Mark::Base -end -class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < Regexp::Expression::UnicodeProperty::Mark::Base -end -class Regexp::Expression::UnicodeProperty::Mark::Spacing < Regexp::Expression::UnicodeProperty::Mark::Base -end -class Regexp::Expression::UnicodeProperty::Mark::Enclosing < Regexp::Expression::UnicodeProperty::Mark::Base -end -module Regexp::Expression::UnicodeProperty::Number -end -class Regexp::Expression::UnicodeProperty::Number::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Number::Any < Regexp::Expression::UnicodeProperty::Number::Base -end -class Regexp::Expression::UnicodeProperty::Number::Decimal < Regexp::Expression::UnicodeProperty::Number::Base -end -class Regexp::Expression::UnicodeProperty::Number::Letter < Regexp::Expression::UnicodeProperty::Number::Base -end -class Regexp::Expression::UnicodeProperty::Number::Other < Regexp::Expression::UnicodeProperty::Number::Base -end -module Regexp::Expression::UnicodeProperty::Punctuation -end -class Regexp::Expression::UnicodeProperty::Punctuation::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Any < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Connector < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Dash < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Open < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Close < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Initial < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Final < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -class Regexp::Expression::UnicodeProperty::Punctuation::Other < Regexp::Expression::UnicodeProperty::Punctuation::Base -end -module Regexp::Expression::UnicodeProperty::Separator -end -class Regexp::Expression::UnicodeProperty::Separator::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Separator::Any < Regexp::Expression::UnicodeProperty::Separator::Base -end -class Regexp::Expression::UnicodeProperty::Separator::Space < Regexp::Expression::UnicodeProperty::Separator::Base -end -class Regexp::Expression::UnicodeProperty::Separator::Line < Regexp::Expression::UnicodeProperty::Separator::Base -end -class Regexp::Expression::UnicodeProperty::Separator::Paragraph < Regexp::Expression::UnicodeProperty::Separator::Base -end -module Regexp::Expression::UnicodeProperty::Symbol -end -class Regexp::Expression::UnicodeProperty::Symbol::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Symbol::Any < Regexp::Expression::UnicodeProperty::Symbol::Base -end -class Regexp::Expression::UnicodeProperty::Symbol::Math < Regexp::Expression::UnicodeProperty::Symbol::Base -end -class Regexp::Expression::UnicodeProperty::Symbol::Currency < Regexp::Expression::UnicodeProperty::Symbol::Base -end -class Regexp::Expression::UnicodeProperty::Symbol::Modifier < Regexp::Expression::UnicodeProperty::Symbol::Base -end -class Regexp::Expression::UnicodeProperty::Symbol::Other < Regexp::Expression::UnicodeProperty::Symbol::Base -end -module Regexp::Expression::UnicodeProperty::Codepoint -end -class Regexp::Expression::UnicodeProperty::Codepoint::Base < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::Any < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::Control < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::Format < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < Regexp::Expression::UnicodeProperty::Codepoint::Base -end -class Regexp::Expression::UnicodeProperty::Age < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Derived < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Emoji < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Script < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::Expression::UnicodeProperty::Block < Regexp::Expression::UnicodeProperty::Base -end -class Regexp::MatchLength - def base_max; end - def base_max=(arg0); end - def base_min; end - def base_min=(arg0); end - def each(opts = nil); end - def endless_each; end - def exp_class; end - def exp_class=(arg0); end - def fixed?; end - def include?(length); end - def initialize(exp, opts = nil); end - def inspect; end - def max; end - def max_rep; end - def max_rep=(arg0); end - def min; end - def min_rep; end - def min_rep=(arg0); end - def minmax; end - def reify; end - def reify=(arg0); end - def self.of(obj); end - def test_regexp; end - def to_re; end - include Enumerable -end -class Regexp::Parser::ParserError < Regexp::Parser::Error -end -class Regexp::Parser::UnknownTokenTypeError < Regexp::Parser::ParserError - def initialize(type, token); end -end -class Regexp::Parser::UnknownTokenError < Regexp::Parser::ParserError - def initialize(type, token); end -end diff --git a/sorbet/rbi/gems/regexp_parser@2.5.0.rbi b/sorbet/rbi/gems/regexp_parser@2.5.0.rbi new file mode 100644 index 00000000..df5208c2 --- /dev/null +++ b/sorbet/rbi/gems/regexp_parser@2.5.0.rbi @@ -0,0 +1,3383 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `regexp_parser` gem. +# Please instead update this file by running `bin/tapioca gem regexp_parser`. + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:1 +module Regexp::Expression; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/alternation.rb:5 +class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:5 + def alternatives; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:127 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/alternation.rb:6 +Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative + +# A sequence of expressions, used by Alternation as one of its alternative. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/alternation.rb:3 +class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:2 +module Regexp::Expression::Anchor; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:18 +Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:20 +Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:3 +class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:144 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:5 +class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:8 +class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:19 +Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:21 +Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:22 +Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:6 +class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:9 +class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:11 +class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:16 +class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:14 +class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/anchor.rb:13 +class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:76 +module Regexp::Expression::Assertion; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:77 +class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:144 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:79 +class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:82 +class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:80 +class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:83 +class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base; end + +# TODO: unify name with token :backref, one way or the other, in v3.0.0 +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:3 +module Regexp::Expression::Backreference; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:4 +class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:151 + def match_length; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:5 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:5 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:7 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:23 +class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backreference::Base + # @return [Name] a new instance of Name + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:27 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute name. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:24 + def name; end + + # Returns the value of attribute name. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:24 + def reference; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:39 +class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:51 +class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name + # @return [NameRecursionLevel] a new instance of NameRecursionLevel + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:54 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute recursion_level. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:52 + def recursion_level; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:13 +class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backreference::Base + # @return [Number] a new instance of Number + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:17 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:14 + def number; end + + # Returns the value of attribute number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:14 + def reference; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:38 +class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:40 +class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:42 +class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number + # @return [NumberRecursionLevel] a new instance of NumberRecursionLevel + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:45 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute recursion_level. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:43 + def recursion_level; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:33 +class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::Backreference::Number + # Returns the value of attribute effective_number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:34 + def effective_number; end + + # Sets the attribute effective_number + # + # @param value the value to set the attribute effective_number to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:34 + def effective_number=(_arg0); end + + # Returns the value of attribute effective_number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/backreference.rb:34 + def reference; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:2 +class Regexp::Expression::Base + include ::Regexp::Expression::Shared + extend ::Regexp::Expression::Shared::ClassMethods + + # @return [Base] a new instance of Base + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:5 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match.rb:8 + def =~(string, offset = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:25 + def a?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:25 + def ascii_classes?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:59 + def attributes; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:8 + def case_insensitive?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def conditional_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def conditional_level=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:20 + def d?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:20 + def default_classes?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:14 + def extended?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:14 + def free_spacing?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:46 + def greedy?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:8 + def i?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:8 + def ignore_case?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:50 + def lazy?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def level=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:3 + def m?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match.rb:8 + def match(string, offset = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match.rb:3 + def match?(string); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match.rb:3 + def matches?(string); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:3 + def multiline?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:13 + def nesting_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def options; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def options=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:55 + def possessive?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def quantifier; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def quantifier=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:20 + def quantify(*args); end + + # Deprecated. Prefer `#repetitions` which has a more uniform interface. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:29 + def quantity; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:50 + def reluctant?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:34 + def repetitions; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def set_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def set_level=(_arg0); end + + # %l Level (depth) of the expression. Returns 'root' for the root + # expression, returns zero or higher for all others. + # + # %> Indentation at expression's level. + # + # %x Index of the expression at its depth. Available when using + # the sprintf_tree method only. + # + # %s Start offset within the whole expression. + # %e End offset within the whole expression. + # %S Length of expression. + # + # %o Coded offset and length, same as '@%s+%S' + # + # %y Type of expression. + # %k Token of expression. + # %i ID, same as '%y:%k' + # %c Class name + # + # %q Quantifier info, as {m[,M]} + # %Q Quantifier text + # + # %z Quantifier min + # %Z Quantifier max + # + # %t Base text of the expression (excludes quantifier, if any) + # %~t Full text if the expression is terminal, otherwise %i + # %T Full text of the expression (includes quantifier, if any) + # + # %b Basic info, same as '%o %i' + # %m Most info, same as '%b %q' + # %a All info, same as '%m %t' + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/strfregexp.rb:37 + def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end + + # %l Level (depth) of the expression. Returns 'root' for the root + # expression, returns zero or higher for all others. + # + # %> Indentation at expression's level. + # + # %x Index of the expression at its depth. Available when using + # the sprintf_tree method only. + # + # %s Start offset within the whole expression. + # %e End offset within the whole expression. + # %S Length of expression. + # + # %o Coded offset and length, same as '@%s+%S' + # + # %y Type of expression. + # %k Token of expression. + # %i ID, same as '%y:%k' + # %c Class name + # + # %q Quantifier info, as {m[,M]} + # %Q Quantifier text + # + # %z Quantifier min + # %Z Quantifier max + # + # %t Base text of the expression (excludes quantifier, if any) + # %~t Full text if the expression is terminal, otherwise %i + # %T Full text of the expression (includes quantifier, if any) + # + # %b Basic info, same as '%o %i' + # %m Most info, same as '%b %q' + # %a All info, same as '%m %t' + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/strfregexp.rb:37 + def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def te; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def te=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def text; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def text=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:59 + def to_h; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:16 + def to_re(format = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def token; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def token=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def ts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def ts=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def type; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def type=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:30 + def u?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:30 + def unicode_classes?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:24 + def unquantified_clone; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/options.rb:14 + def x?; end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/base.rb:9 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:2 +class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression + # @return [CharacterSet] a new instance of CharacterSet + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:9 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:19 + def close; end + + # Returns the value of attribute closed. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def closed; end + + # Sets the attribute closed + # + # @param value the value to set the attribute closed to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def closed=(_arg0); end + + # Returns the value of attribute closed. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def closed?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:15 + def negate; end + + # Returns the value of attribute negative. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def negated?; end + + # Returns the value of attribute negative. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def negative; end + + # Sets the attribute negative + # + # @param value the value to set the attribute negative to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def negative=(_arg0); end + + # Returns the value of attribute negative. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:3 + def negative?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set.rb:23 + def parts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/intersection.rb:3 +class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/intersection.rb:5 +class Regexp::Expression::CharacterSet::Intersection < ::Regexp::Expression::SequenceOperation + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/intersection.rb:6 +Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:3 +class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpression + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:9 + def <<(exp); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:15 + def complete?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:19 + def parts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:4 + def starts_at; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_set/range.rb:4 + def ts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:2 +module Regexp::Expression::CharacterType; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:5 +class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:3 +class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:6 +class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:15 +class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:8 +class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:14 +class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:7 +class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:9 +class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:13 +class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:11 +class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:12 +class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/character_type.rb:10 +class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/free_space.rb:8 +class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:2 +module Regexp::Expression::Conditional; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:25 +class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:9 +class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:144 + def match_length; end + + # Name or number of the referenced capturing group that determines state. + # Returns a String if reference is by name, Integer if by number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:14 + def reference; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:10 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:10 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:19 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:27 +class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexpression + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:30 + def <<(exp); end + + # @raise [TooManyBranches] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:34 + def add_sequence(active_opts = T.unsafe(nil)); end + + # @raise [TooManyBranches] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:34 + def branch(active_opts = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:50 + def branches; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:46 + def condition; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:41 + def condition=(exp); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:127 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:58 + def parts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:54 + def reference; end + + # Returns the value of attribute referenced_expression. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:28 + def referenced_expression; end + + # Sets the attribute referenced_expression + # + # @param value the value to set the attribute referenced_expression to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:28 + def referenced_expression=(_arg0); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:62 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:3 +class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error + # @return [TooManyBranches] a new instance of TooManyBranches + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/conditional.rb:4 + def initialize; end +end + +# TODO: unify naming with Token::Escape, on way or the other, in v3.0.0 +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:3 +module Regexp::Expression::EscapeSequence; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:64 +class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:65 + def char; end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:71 + def control_sequence_to_s(control_sequence); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:76 + def meta_char_to_codepoint(meta_char); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:28 +class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:29 +class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:4 +class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:10 + def char; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:5 + def codepoint; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:30 +class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:38 +class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:40 +class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base + # @raise [NoMethodError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:41 + def char; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:49 + def chars; end + + # @raise [NoMethodError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:45 + def codepoint; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:53 + def codepoints; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:160 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:82 +class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:83 + def codepoint; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:31 +class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:37 +class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:22 +class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:23 + def char; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:88 +class Regexp::Expression::EscapeSequence::Meta < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:89 + def codepoint; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:94 +class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::EscapeSequence::AbstractMetaControlSequence + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:95 + def codepoint; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:32 +class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:58 +class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:59 + def char; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:33 +class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:34 +class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/escape_sequence.rb:35 +class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/free_space.rb:2 +class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:144 + def match_length; end + + # @raise [Regexp::Parser::Error] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/free_space.rb:3 + def quantify(*_args); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:2 +module Regexp::Expression::Group; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:34 +class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:168 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:35 +class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:3 +class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:8 + def capturing?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:10 + def comment?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:4 + def parts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:45 +class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:49 + def capturing?; end + + # Returns the value of attribute number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:46 + def identifier; end + + # Returns the value of attribute number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:46 + def number; end + + # Sets the attribute number + # + # @param value the value to set the attribute number to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:46 + def number=(_arg0); end + + # Returns the value of attribute number_at_level. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:46 + def number_at_level; end + + # Sets the attribute number_at_level + # + # @param value the value to set the attribute number_at_level to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:46 + def number_at_level=(_arg0); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:67 +class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:72 + def comment?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:68 + def parts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:52 +class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture + # @return [Named] a new instance of Named + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:56 + def initialize(token, options = T.unsafe(nil)); end + + # Returns the value of attribute name. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:53 + def identifier; end + + # Returns the value of attribute name. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:53 + def name; end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:61 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:36 +class Regexp::Expression::Group::Options < ::Regexp::Expression::Group::Base + # Returns the value of attribute option_changes. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:37 + def option_changes; end + + # Sets the attribute option_changes + # + # @param value the value to set the attribute option_changes to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:37 + def option_changes=(_arg0); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:39 + def initialize_copy(orig); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:13 +class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base + # @return [Passive] a new instance of Passive + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:16 + def initialize(*_arg0); end + + # Sets the attribute implicit + # + # @param value the value to set the attribute implicit to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:14 + def implicit=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:29 + def implicit?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/group.rb:21 + def parts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/keep.rb:2 +module Regexp::Expression::Keep; end + +# TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression +# that contains all expressions to its left. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/keep.rb:5 +class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:144 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/literal.rb:2 +class Regexp::Expression::Literal < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:101 + def match_length; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:81 +Regexp::Expression::MatchLength = Regexp::MatchLength + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/posix_class.rb:2 +class Regexp::Expression::PosixClass < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/posix_class.rb:7 + def name; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/posix_class.rb:3 + def negative?; end +end + +# TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and +# call super in #initialize, but raise in #quantifier= and #quantify, +# or introduce an Expression::Quantifiable intermediate class. +# Or actually allow chaining as a more concise but tricky solution than PR#69. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:6 +class Regexp::Expression::Quantifier + include ::Regexp::Expression::Shared + extend ::Regexp::Expression::Shared::ClassMethods + + # @return [Quantifier] a new instance of Quantifier + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:13 + def initialize(*args); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def conditional_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def conditional_level=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:35 + def greedy?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:35 + def lazy?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def level=(_arg0); end + + # Returns the value of attribute max. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:11 + def max; end + + # Returns the value of attribute min. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:11 + def min; end + + # Returns the value of attribute mode. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:11 + def mode; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:13 + def nesting_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def options; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def options=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:35 + def possessive?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def quantifier; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def quantifier=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:35 + def reluctant?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def set_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def set_level=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def te; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def te=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def text; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def text=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:23 + def to_h; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def token; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def token=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def ts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def ts=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def type; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def type=(_arg0); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:44 + def deprecated_old_init(token, text, min, max, mode = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:59 + def minmax; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/quantifier.rb:9 +Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/root.rb:2 +class Regexp::Expression::Root < ::Regexp::Expression::Subexpression + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/root.rb:3 + def build(options = T.unsafe(nil)); end + end +end + +# A sequence of expressions. Differs from a Subexpressions by how it handles +# quantifiers, as it applies them to its last element instead of itself as +# a whole subexpression. +# +# Used as the base class for the Alternation alternatives, Conditional +# branches, and CharacterSet::Intersection intersected sequences. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence.rb:8 +class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence.rb:28 + def quantify(*args); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence.rb:23 + def starts_at; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence.rb:23 + def ts; end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence.rb:10 + def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end + end +end + +# abstract class +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:3 +class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpression + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:13 + def <<(exp); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:17 + def add_sequence(active_opts = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:5 + def operands; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:9 + def operator; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:21 + def parts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:5 + def sequences; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:8 + def starts_at; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/sequence_operation.rb:8 + def ts; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:2 +module Regexp::Expression::Shared + mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods + + # Deep-compare two expressions for equality. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:98 + def ==(other); end + + # Deep-compare two expressions for equality. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:98 + def ===(other); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:42 + def base_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:71 + def coded_offset; end + + # Deep-compare two expressions for equality. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:98 + def eql?(other); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:46 + def full_length; end + + # Test if this expression has the given test_token, and optionally a given + # test_type. + # + # # Any expressions + # exp.is? :* # always returns true + # + # # is it a :capture + # exp.is? :capture + # + # # is it a :character and a :set + # exp.is? :character, :set + # + # # is it a :meta :dot + # exp.is? :dot, :meta + # + # # is it a :meta or :escape :dot + # exp.is? :dot, [:meta, :escape] + # + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:36 + def is?(test_token, test_type = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:79 + def nesting_level=(lvl); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:67 + def offset; end + + # Test if this expression matches an entry in the given scope spec. + # + # A scope spec can be one of: + # + # . An array: Interpreted as a set of tokens, tested for inclusion + # of the expression's token. + # + # . A hash: Where the key is interpreted as the expression type + # and the value is either a symbol or an array. In this + # case, when the scope is a hash, one_of? calls itself to + # evaluate the key's value. + # + # . A symbol: matches the expression's token or type, depending on + # the level of the call. If one_of? is called directly with + # a symbol then it will always be checked against the + # type of the expression. If it's being called for a value + # from a hash, it will be checked against the token of the + # expression. + # + # # any expression + # exp.one_of?(:*) # always true + # + # # like exp.type?(:group) + # exp.one_of?(:group) + # + # # any expression of type meta + # exp.one_of?(:meta => :*) + # + # # meta dots and alternations + # exp.one_of?(:meta => [:dot, :alternation]) + # + # # meta dots and any set tokens + # exp.one_of?({meta: [:dot], set: :*}) + # + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:75 + def one_of?(scope, top = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:55 + def parts; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:63 + def quantified?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:59 + def quantifier_affix(expression_format); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:38 + def starts_at; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:75 + def terminal?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:50 + def to_s(format = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:50 + def to_str(format = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/construct.rb:39 + def token_class; end + + # Test if this expression has the given test_type, which can be either + # a symbol or an array of symbols to check against the expression's type. + # + # # is it a :group expression + # exp.type? :group + # + # # is it a :set, or :meta + # exp.type? [:set, :meta] + # + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/tests.rb:13 + def type?(test_type); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:17 + def init_from_token_and_options(token, options = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:31 + def initialize_copy(orig); end + + class << self + # @private + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:5 + def included(mod); end + end +end + +# filled in ./methods/*.rb +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/shared.rb:3 +module Regexp::Expression::Shared::ClassMethods + # Convenience method to init a valid Expression without a Regexp::Token + # + # @raise [ArgumentError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/construct.rb:5 + def construct(params = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/construct.rb:15 + def construct_defaults; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/construct.rb:25 + def token_class; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:2 +class Regexp::Expression::Subexpression < ::Regexp::Expression::Base + include ::Enumerable + + # @return [Subexpression] a new instance of Subexpression + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:7 + def initialize(token, options = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:18 + def <<(exp); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def [](*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def at(*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:35 + def dig(*indices); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def each(*args, &block); end + + # Iterates over the expressions of this expression as an array, passing + # the expression and its index within its parent to the given block. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/traverse.rb:39 + def each_expression(include_self = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def empty?(*args, &block); end + + # Returns the value of attribute expressions. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:5 + def expressions; end + + # Sets the attribute expressions + # + # @param value the value to set the attribute expressions to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:5 + def expressions=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def fetch(*args, &block); end + + # Returns a new array with the results of calling the given block once + # for every expression. If a block is not given, returns an array with + # each expression and its level index as an array. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/traverse.rb:50 + def flat_map(include_self = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def index(*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:114 + def inner_match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def join(*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def last(*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def length(*args, &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:107 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:45 + def parts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/strfregexp.rb:102 + def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/strfregexp.rb:102 + def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:41 + def te; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:49 + def to_h; end + + # Traverses the subexpression (depth-first, pre-order) and calls the given + # block for each expression with three arguments; the traversal event, + # the expression, and the index of the expression within its parent. + # + # The event argument is passed as follows: + # + # - For subexpressions, :enter upon entering the subexpression, and + # :exit upon exiting it. + # + # - For terminal expressions, :visit is called once. + # + # Returns self. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/traverse.rb:16 + def traverse(include_self = T.unsafe(nil), &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:29 + def values_at(*args, &block); end + + # Traverses the subexpression (depth-first, pre-order) and calls the given + # block for each expression with three arguments; the traversal event, + # the expression, and the index of the expression within its parent. + # + # The event argument is passed as follows: + # + # - For subexpressions, :enter upon entering the subexpression, and + # :exit upon exiting it. + # + # - For terminal expressions, :visit is called once. + # + # Returns self. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/traverse.rb:16 + def walk(include_self = T.unsafe(nil), &block); end + + private + + # Override base method to clone the expressions as well. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:13 + def initialize_copy(orig); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/subexpression.rb:58 + def intersperse(expressions, separator); end +end + +# TODO: unify name with token :property, on way or the other, in v3.0.0 +# +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:3 +module Regexp::Expression::UnicodeProperty; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:113 +class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:18 +class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:19 +class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:36 +class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:20 +class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:37 +class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:4 +class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:94 + def match_length; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:9 + def name; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:5 + def negative?; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:13 + def shortcut; end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:21 +class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:117 +class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:22 +class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:102 +module Regexp::Expression::UnicodeProperty::Codepoint; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:105 +class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:103 +class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:106 +class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:107 +class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:109 +class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:108 +class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:110 +class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:114 +class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:23 +class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:115 +class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:24 +class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:39 +module Regexp::Expression::UnicodeProperty::Letter; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:42 +class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:40 +class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:43 +class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:45 +class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:47 +class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:48 +class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:46 +class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:44 +class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:25 +class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:51 +module Regexp::Expression::UnicodeProperty::Mark; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:54 +class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:52 +class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:55 +class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:58 +class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:56 +class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:57 +class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:34 +class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:61 +module Regexp::Expression::UnicodeProperty::Number; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:64 +class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:62 +class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:65 +class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:66 +class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:67 +class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:26 +class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:27 +class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:70 +module Regexp::Expression::UnicodeProperty::Punctuation; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:73 +class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:71 +class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:77 +class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:74 +class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:75 +class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:79 +class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:78 +class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:76 +class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:80 +class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:116 +class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:83 +module Regexp::Expression::UnicodeProperty::Separator; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:86 +class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:84 +class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:88 +class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:89 +class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:87 +class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:28 +class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:92 +module Regexp::Expression::UnicodeProperty::Symbol; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:95 +class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:93 +class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:97 +class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:96 +class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:98 +class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:99 +class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:29 +class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:30 +class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:32 +class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/unicode_property.rb:31 +class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/free_space.rb:10 +class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/classes/free_space.rb:11 + def merge(exp); end +end + +# A very thin wrapper around the scanner that breaks quantified literal runs, +# collects emitted tokens into an array, calculates their nesting depth, and +# normalizes tokens for the parser, and checks if they are implemented by the +# given syntax flavor. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:5 +class Regexp::Lexer + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:20 + def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:71 + def ascend(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:108 + def break_codepoint_list(token); end + + # called by scan to break a literal run that is longer than one character + # into two separate tokens when it is followed by a quantifier + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:95 + def break_literal(token); end + + # Returns the value of attribute conditional_nesting. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def conditional_nesting; end + + # Sets the attribute conditional_nesting + # + # @param value the value to set the attribute conditional_nesting to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def conditional_nesting=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:82 + def descend(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:123 + def merge_condition(current); end + + # Returns the value of attribute nesting. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def nesting; end + + # Sets the attribute nesting + # + # @param value the value to set the attribute nesting to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def nesting=(_arg0); end + + # Returns the value of attribute set_nesting. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def set_nesting; end + + # Sets the attribute set_nesting + # + # @param value the value to set the attribute set_nesting to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def set_nesting=(_arg0); end + + # Returns the value of attribute shift. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def shift; end + + # Sets the attribute shift + # + # @param value the value to set the attribute shift to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def shift=(_arg0); end + + # Returns the value of attribute tokens. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def tokens; end + + # Sets the attribute tokens + # + # @param value the value to set the attribute tokens to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:69 + def tokens=(_arg0); end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:16 + def lex(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:16 + def scan(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:12 +Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:14 +Regexp::Lexer::CONDITION_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/lexer.rb:7 +Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:1 +class Regexp::MatchLength + include ::Enumerable + + # @return [MatchLength] a new instance of MatchLength + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:9 + def initialize(exp, opts = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:24 + def each(opts = T.unsafe(nil)); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:35 + def endless_each; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:44 + def fixed?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:40 + def include?(length); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:60 + def inspect; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:52 + def max; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:48 + def min; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:56 + def minmax; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:65 + def to_re; end + + private + + # Returns the value of attribute base_max. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def base_max; end + + # Sets the attribute base_max + # + # @param value the value to set the attribute base_max to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def base_max=(_arg0); end + + # Returns the value of attribute base_min. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def base_min; end + + # Sets the attribute base_min + # + # @param value the value to set the attribute base_min to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def base_min=(_arg0); end + + # Returns the value of attribute exp_class. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def exp_class; end + + # Sets the attribute exp_class + # + # @param value the value to set the attribute exp_class to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def exp_class=(_arg0); end + + # Returns the value of attribute max_rep. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def max_rep; end + + # Sets the attribute max_rep + # + # @param value the value to set the attribute max_rep to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def max_rep=(_arg0); end + + # Returns the value of attribute min_rep. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def min_rep; end + + # Sets the attribute min_rep + # + # @param value the value to set the attribute min_rep to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def min_rep=(_arg0); end + + # Returns the value of attribute reify. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def reify; end + + # Sets the attribute reify + # + # @param value the value to set the attribute reify to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:71 + def reify=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:73 + def test_regexp; end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/expression/methods/match_length.rb:4 + def of(obj); end + end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/version.rb:2 +class Regexp::Parser + include ::Regexp::Expression + include ::Regexp::Expression::UnicodeProperty + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:25 + def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:564 + def active_opts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:99 + def anchor(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:254 + def assign_effective_number(exp); end + + # Assigns referenced expressions to refering expressions, e.g. if there is + # an instance of Backreference::Number, its #referenced_expression is set to + # the instance of Group::Capture that it refers to via its number. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:571 + def assign_referenced_expressions; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:227 + def backref(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:202 + def captured_group_count_at_level; end + + # Returns the value of attribute captured_group_counts. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def captured_group_counts; end + + # Sets the attribute captured_group_counts + # + # @param value the value to set the attribute captured_group_counts to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def captured_group_counts=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:560 + def close_completed_character_set_range; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:210 + def close_group; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:528 + def close_set; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:259 + def conditional(token); end + + # Returns the value of attribute conditional_nesting. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def conditional_nesting; end + + # Sets the attribute conditional_nesting + # + # @param value the value to set the attribute conditional_nesting to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def conditional_nesting=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:206 + def count_captured_group; end + + # @yield [node] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:216 + def decrease_nesting; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:295 + def escape(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:60 + def extract_options(input, options); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:337 + def free_space(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:114 + def group(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:501 + def increase_group_level(exp); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:539 + def intersection(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:352 + def keep(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:356 + def literal(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:360 + def meta(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:524 + def negate_set; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:289 + def nest(exp); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:284 + def nest_conditional(exp); end + + # Returns the value of attribute nesting. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def nesting; end + + # Sets the attribute nesting + # + # @param value the value to set the attribute nesting to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def nesting=(_arg0); end + + # Returns the value of attribute node. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def node; end + + # Sets the attribute node + # + # @param value the value to set the attribute node to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def node=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:165 + def open_group(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:519 + def open_set(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:130 + def options_group(token); end + + # Returns the value of attribute options_stack. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def options_stack; end + + # Sets the attribute options_stack + # + # @param value the value to set the attribute options_stack to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def options_stack=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:76 + def parse_token(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:382 + def posixclass(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:389 + def property(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:470 + def quantifier(token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:532 + def range(token); end + + # Returns the value of attribute root. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def root; end + + # Sets the attribute root + # + # @param value the value to set the attribute root to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def root=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:371 + def sequence_operation(klass, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:507 + def set(token); end + + # Returns the value of attribute switching_options. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def switching_options; end + + # Sets the attribute switching_options + # + # @param value the value to set the attribute switching_options to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:56 + def switching_options=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:198 + def total_captured_group_count; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:543 + def type(token); end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:21 + def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end + end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:128 +Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array) + +# base class for all gem-specific errors +# +# source://regexp_parser-2.5.0/lib/regexp_parser/error.rb:3 +class Regexp::Parser::Error < ::StandardError; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:127 +Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:7 +class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:387 +Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:15 +class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError + # @return [UnknownTokenError] a new instance of UnknownTokenError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:16 + def initialize(type, token); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:9 +class Regexp::Parser::UnknownTokenTypeError < ::Regexp::Parser::ParserError + # @return [UnknownTokenTypeError] a new instance of UnknownTokenTypeError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/parser.rb:10 + def initialize(type, token); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/version.rb:3 +Regexp::Parser::VERSION = T.let(T.unsafe(nil), String) + +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:13 +class Regexp::Scanner + # Emits an array with the details of the scanned pattern + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2551 + def emit(type, token, text); end + + # @raise [PrematureEndError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:84 + def scan(input_object, options: T.unsafe(nil), &block); end + + private + + # Appends one or more characters to the literal buffer, to be emitted later + # by a call to emit_literal. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2602 + def append_literal(data, ts, te); end + + # Returns the value of attribute block. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def block=(_arg0); end + + # Returns the value of attribute char_pos. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def char_pos; end + + # Sets the attribute char_pos + # + # @param value the value to set the attribute char_pos to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def char_pos=(_arg0); end + + # Returns the value of attribute conditional_stack. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def conditional_stack; end + + # Sets the attribute conditional_stack + # + # @param value the value to set the attribute conditional_stack to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def conditional_stack=(_arg0); end + + # Copy from ts to te from data as text + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2596 + def copy(data, ts, te); end + + # Emits the literal run collected by calls to the append_literal method. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2608 + def emit_literal; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2643 + def emit_meta_control_sequence(data, ts, te, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2614 + def emit_options(text); end + + # Returns the value of attribute free_spacing. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def free_spacing; end + + # Sets the attribute free_spacing + # + # @param value the value to set the attribute free_spacing to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def free_spacing=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2575 + def free_spacing?(input_object, options); end + + # Returns the value of attribute group_depth. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def group_depth; end + + # Sets the attribute group_depth + # + # @param value the value to set the attribute group_depth to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def group_depth=(_arg0); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2587 + def in_group?; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2591 + def in_set?; end + + # Returns the value of attribute literal. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def literal; end + + # Sets the attribute literal + # + # @param value the value to set the attribute literal to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def literal=(_arg0); end + + # Returns the value of attribute set_depth. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def set_depth; end + + # Sets the attribute set_depth + # + # @param value the value to set the attribute set_depth to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def set_depth=(_arg0); end + + # Returns the value of attribute spacing_stack. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def spacing_stack; end + + # Sets the attribute spacing_stack + # + # @param value the value to set the attribute spacing_stack to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def spacing_stack=(_arg0); end + + # Returns the value of attribute tokens. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def tokens; end + + # Sets the attribute tokens + # + # @param value the value to set the attribute tokens to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2572 + def tokens=(_arg0); end + + # Centralizes and unifies the handling of validation related + # errors. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2652 + def validation_error(type, what, reason = T.unsafe(nil)); end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2537 + def long_prop_map; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2541 + def parse_prop_map(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2545 + def posix_classes; end + + # Scans the given regular expression text, or Regexp object and collects the + # emitted token into an array that gets returned at the end. If a block is + # given, it gets called for each emitted token. + # + # This method may raise errors if a syntax error is encountered. + # -------------------------------------------------------------------------- + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:80 + def scan(input_object, options: T.unsafe(nil), &block); end + + # lazy-load property maps when first needed + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:2533 + def short_prop_map; end + end +end + +# Invalid back reference. Used for name a number refs/calls. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:54 +class Regexp::Scanner::InvalidBackrefError < ::Regexp::Scanner::ValidationError + # @return [InvalidBackrefError] a new instance of InvalidBackrefError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:55 + def initialize(what, reason); end +end + +# Invalid group. Used for named groups. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:39 +class Regexp::Scanner::InvalidGroupError < ::Regexp::Scanner::ValidationError + # @return [InvalidGroupError] a new instance of InvalidGroupError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:40 + def initialize(what, reason); end +end + +# Invalid groupOption. Used for inline options. +# TODO: should become InvalidGroupOptionError in v3.0.0 for consistency +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:47 +class Regexp::Scanner::InvalidGroupOption < ::Regexp::Scanner::ValidationError + # @return [InvalidGroupOption] a new instance of InvalidGroupOption + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:48 + def initialize(option, text); end +end + +# Invalid sequence format. Used for escape sequences, mainly. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:32 +class Regexp::Scanner::InvalidSequenceError < ::Regexp::Scanner::ValidationError + # @return [InvalidSequenceError] a new instance of InvalidSequenceError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:33 + def initialize(what = T.unsafe(nil), where = T.unsafe(nil)); end +end + +# Unexpected end of pattern +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:25 +class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError + # @return [PrematureEndError] a new instance of PrematureEndError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:26 + def initialize(where = T.unsafe(nil)); end +end + +# General scanner error (catch all) +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:15 +class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end + +# The POSIX class name was not recognized by the scanner. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:68 +class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError + # @return [UnknownPosixClassError] a new instance of UnknownPosixClassError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:69 + def initialize(text); end +end + +# The property name was not recognized by the scanner. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:61 +class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError + # @return [UnknownUnicodePropertyError] a new instance of UnknownUnicodePropertyError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:62 + def initialize(name); end +end + +# Base for all scanner validation errors +# +# source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:18 +class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error + # @return [ValidationError] a new instance of ValidationError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/scanner.rb:19 + def initialize(reason); end +end + +# After loading all the tokens the map is full. Extract all tokens and types +# into the All and Types constants. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax.rb:3 +module Regexp::Syntax + private + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:62 + def comparable(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:45 + def const_missing(const_name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:52 + def fallback_version_class(version); end + + # Returns the syntax specification class for the given syntax + # version name. The special names 'any' and '*' return Syntax::Any. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:22 + def for(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:26 + def new(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:58 + def specified_versions; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:32 + def supported?(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:36 + def version_class(version); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:67 + def warn_if_future_version(const_name); end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:62 + def comparable(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:45 + def const_missing(const_name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:52 + def fallback_version_class(version); end + + # Returns the syntax specification class for the given syntax + # version name. The special names 'any' and '*' return Syntax::Any. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:22 + def for(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:26 + def new(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:58 + def specified_versions; end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:32 + def supported?(name); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:36 + def version_class(version); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:67 + def warn_if_future_version(const_name); end + end +end + +# A syntax that always returns true, passing all tokens as implemented. This +# is useful during development, testing, and should be useful for some types +# of transformations as well. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/any.rb:5 +class Regexp::Syntax::Any < ::Regexp::Syntax::Base + class << self + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/any.rb:8 + def implements?(_type, _token); end + end +end + +# A lookup map of supported types and tokens in a given syntax +# +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:9 +class Regexp::Syntax::Base + include ::Regexp::Syntax::Token + + # TODO: drop this backwards compatibility code in v3.0.0, do `private :new` + # + # @return [Base] a new instance of Base + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:99 + def initialize; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:104 + def method_missing(name, *args); end + + private + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:115 + def respond_to_missing?(name, include_private = T.unsafe(nil)); end + + class << self + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:46 + def added_features; end + + # @raise [NotImplementedError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:40 + def check!(type, token); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:31 + def check?(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:26 + def excludes(type, tokens); end + + # Returns the value of attribute features. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:13 + def features; end + + # Sets the attribute features + # + # @param value the value to set the attribute features to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:13 + def features=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:36 + def implementations(type); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:21 + def implements(type, tokens); end + + # @raise [NotImplementedError] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:40 + def implements!(type, token); end + + # @return [Boolean] + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:31 + def implements?(type, token); end + + # automatically inherit features through the syntax class hierarchy + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:16 + def inherited(subclass); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:54 + def normalize(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:74 + def normalize_backref(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:65 + def normalize_group(type, token); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:50 + def removed_features; end + end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:6 +class Regexp::Syntax::InvalidVersionNameError < ::Regexp::Syntax::SyntaxError + # @return [InvalidVersionNameError] a new instance of InvalidVersionNameError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:7 + def initialize(name); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:2 +class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError + # @return [NotImplementedError] a new instance of NotImplementedError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/base.rb:3 + def initialize(syntax, type, token); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax.rb:4 +class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:3 +module Regexp::Syntax::Token; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:42 +Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:3 +module Regexp::Syntax::Token::Anchor; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:9 +Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:4 +Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:5 +Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:7 +Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:6 +Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/anchor.rb:10 +Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/assertion.rb:3 +module Regexp::Syntax::Token::Assertion; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/assertion.rb:7 +Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/assertion.rb:4 +Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/assertion.rb:5 +Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/assertion.rb:8 +Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:3 +module Regexp::Syntax::Token::Backreference; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:15 +Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:7 +Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:6 +Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:5 +Regexp::Syntax::Token::Backreference::NumberRef = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:4 +Regexp::Syntax::Token::Backreference::Plain = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:9 +Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:16 +Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:11 +Regexp::Syntax::Token::Backreference::V1_8_6 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:13 +Regexp::Syntax::Token::Backreference::V1_9_1 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_set.rb:3 +module Regexp::Syntax::Token::CharacterSet; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_set.rb:7 +Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_set.rb:4 +Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_set.rb:5 +Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_set.rb:8 +Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:3 +module Regexp::Syntax::Token::CharacterType; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:10 +Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:4 +Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:8 +Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:5 +Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:6 +Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/character_type.rb:11 +Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:3 +module Regexp::Syntax::Token::Conditional; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:9 +Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:6 +Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:4 +Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:7 +Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/conditional.rb:11 +Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol) + +# TODO: unify naming with RE::EscapeSequence, one way or the other, in v3.0.0 +# +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:4 +module Regexp::Syntax::Token::Escape; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:9 +Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:25 +Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:5 +Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:7 +Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:21 +Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:14 +Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:23 +Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:26 +Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/escape.rb:12 +Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:11 +module Regexp::Syntax::Token::FreeSpace; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:12 +Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:13 +Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:3 +module Regexp::Syntax::Token::Group; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:17 +Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:8 +Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:4 +Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:10 +Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:5 +Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:7 +Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:9 +Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:18 +Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:12 +Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/group.rb:15 +Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/keep.rb:3 +module Regexp::Syntax::Token::Keep; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/keep.rb:6 +Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/keep.rb:4 +Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/keep.rb:7 +Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:6 +module Regexp::Syntax::Token::Literal; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:7 +Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:8 +Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:4 +Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/meta.rb:3 +module Regexp::Syntax::Token::Meta; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/meta.rb:7 +Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/meta.rb:4 +Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/meta.rb:5 +Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/meta.rb:8 +Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:3 +module Regexp::Syntax::Token::PosixClass; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:9 +Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:7 +Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:11 +Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:4 +Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/posix_class.rb:10 +Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:3 +module Regexp::Syntax::Token::Quantifier; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:29 +Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:4 +Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:22 +Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:26 +Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:24 +Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:23 +Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:16 +Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:10 +Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:30 +Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/quantifier.rb:28 +Regexp::Syntax::Token::Quantifier::V1_8_6 = T.let(T.unsafe(nil), Array) + +# Type is the same as Backreference so keeping it here, for now. +# +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:20 +module Regexp::Syntax::Token::SubexpressionCall; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:24 +Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:21 +Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/backreference.rb:22 +Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token.rb:43 +Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:3 +module Regexp::Syntax::Token::UnicodeProperty; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:64 +Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:40 +Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:44 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:46 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:48 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:50 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:52 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:54 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:56 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:58 +Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:60 +Regexp::Syntax::Token::UnicodeProperty::Age_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:62 +Regexp::Syntax::Token::UnicodeProperty::Age_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:708 +Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:13 +module Regexp::Syntax::Token::UnicodeProperty::Category; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:36 +Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:33 +Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:14 +Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:17 +Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:20 +Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:23 +Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:30 +Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:27 +Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:6 +Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:9 +Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:133 +Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:66 +Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:120 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:125 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:129 +Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:693 +Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:685 +Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:711 +Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:11 +Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:330 +Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:135 +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:231 +Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:237 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:247 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:273 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:282 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:291 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:298 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:308 +Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:315 +Regexp::Syntax::Token::UnicodeProperty::Script_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:322 +Regexp::Syntax::Token::UnicodeProperty::Script_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:710 +Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:683 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:332 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:431 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:559 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:594 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:607 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:621 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:631 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:645 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:657 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:668 +Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:695 +Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:696 +Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:697 +Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:698 +Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:699 +Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:700 +Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:701 +Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:702 +Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:703 +Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:704 +Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:705 +Regexp::Syntax::Token::UnicodeProperty::V3_1_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/token/unicode_property.rb:706 +Regexp::Syntax::Token::UnicodeProperty::V3_2_0 = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:12 +class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError + # @return [UnknownSyntaxNameError] a new instance of UnknownSyntaxNameError + # + # source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:13 + def initialize(name); end +end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/1.8.6.rb:1 +class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/1.9.1.rb:1 +class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/1.9.3.rb:1 +class Regexp::Syntax::V1_9_3 < ::Regexp::Syntax::V1_9_1; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.0.0.rb:1 +class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9_3; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.2.0.rb:1 +class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_0_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.3.0.rb:1 +class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.4.0.rb:1 +class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.4.1.rb:1 +class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.5.0.rb:1 +class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4_1; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.6.0.rb:1 +class Regexp::Syntax::V2_6_0 < ::Regexp::Syntax::V2_5_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.6.2.rb:1 +class Regexp::Syntax::V2_6_2 < ::Regexp::Syntax::V2_6_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/2.6.3.rb:1 +class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/3.1.0.rb:1 +class Regexp::Syntax::V3_1_0 < ::Regexp::Syntax::V2_6_3; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/versions/3.2.0.rb:1 +class Regexp::Syntax::V3_2_0 < ::Regexp::Syntax::V3_1_0; end + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:4 +Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:2 +Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String) + +# source://regexp_parser-2.5.0/lib/regexp_parser/syntax/version_lookup.rb:3 +Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:2 +Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array) + +# source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 +class Regexp::Token < ::Struct + def conditional_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def conditional_level=(_); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:20 + def length; end + + def level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def level=(_); end + + # Returns the value of attribute next. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:14 + def next; end + + # Sets the attribute next + # + # @param value the value to set the attribute next to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:14 + def next=(_arg0); end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:16 + def offset; end + + # Returns the value of attribute previous. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:14 + def previous; end + + # Sets the attribute previous + # + # @param value the value to set the attribute previous to. + # + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:14 + def previous=(_arg0); end + + def set_level; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def set_level=(_); end + + def te; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def te=(_); end + + def text; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def text=(_); end + + def token; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def token=(_); end + + def ts; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def ts=(_); end + + def type; end + + # source://regexp_parser-2.5.0/lib/regexp_parser/token.rb:13 + def type=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end diff --git a/sorbet/rbi/gems/rexml.rbi b/sorbet/rbi/gems/rexml.rbi deleted file mode 100644 index d3021c41..00000000 --- a/sorbet/rbi/gems/rexml.rbi +++ /dev/null @@ -1,599 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rexml/all/rexml.rbi -# -# rexml-3.2.5 - -module REXML -end -module REXML::Security - def self.entity_expansion_limit; end - def self.entity_expansion_limit=(val); end - def self.entity_expansion_text_limit; end - def self.entity_expansion_text_limit=(val); end -end -class REXML::ParseException < RuntimeError - def context; end - def continued_exception; end - def continued_exception=(arg0); end - def initialize(message, source = nil, parser = nil, exception = nil); end - def line; end - def parser; end - def parser=(arg0); end - def position; end - def source; end - def source=(arg0); end - def to_s; end -end -module REXML::Formatters -end -class REXML::Formatters::Default - def initialize(ie_hack = nil); end - def write(node, output); end - def write_cdata(node, output); end - def write_comment(node, output); end - def write_document(node, output); end - def write_element(node, output); end - def write_instruction(node, output); end - def write_text(node, output); end -end -class REXML::Formatters::Pretty < REXML::Formatters::Default - def compact; end - def compact=(arg0); end - def indent_text(string, level = nil, style = nil, indentfirstline = nil); end - def initialize(indentation = nil, ie_hack = nil); end - def width; end - def width=(arg0); end - def wrap(string, width); end - def write_cdata(node, output); end - def write_comment(node, output); end - def write_document(node, output); end - def write_element(node, output); end - def write_text(node, output); end -end -module REXML::Node - def each_recursive(&block); end - def find_first_recursive(&block); end - def indent(to, ind); end - def index_in_parent; end - def next_sibling_node; end - def parent?; end - def previous_sibling_node; end - def to_s(indent = nil); end -end -class REXML::Child - def bytes; end - def document; end - def initialize(parent = nil); end - def next_sibling; end - def next_sibling=(other); end - def parent; end - def parent=(other); end - def previous_sibling; end - def previous_sibling=(other); end - def remove; end - def replace_with(child); end - include REXML::Node -end -class REXML::Parent < REXML::Child - def <<(object); end - def [](index); end - def []=(*args); end - def add(object); end - def children; end - def deep_clone; end - def delete(object); end - def delete_at(index); end - def delete_if(&block); end - def each(&block); end - def each_child(&block); end - def each_index(&block); end - def index(child); end - def initialize(parent = nil); end - def insert_after(child1, child2); end - def insert_before(child1, child2); end - def length; end - def parent?; end - def push(object); end - def replace_child(to_replace, replacement); end - def size; end - def to_a; end - def unshift(object); end - include Enumerable -end -module REXML::XMLTokens -end -module REXML::Namespace - def expanded_name; end - def fully_expanded_name; end - def has_name?(other, ns = nil); end - def local_name; end - def name; end - def name=(name); end - def prefix; end - def prefix=(arg0); end - include REXML::XMLTokens -end -module REXML::Encoding - def decode(string); end - def encode(string); end - def encoding; end - def encoding=(encoding); end - def find_encoding(name); end -end -class REXML::SourceFactory - def self.create_from(arg); end -end -class REXML::Source - def buffer; end - def consume(pattern); end - def current_line; end - def detect_encoding; end - def empty?; end - def encoding; end - def encoding=(enc); end - def encoding_updated; end - def initialize(arg, encoding = nil); end - def line; end - def match(pattern, cons = nil); end - def match_to(char, pattern); end - def match_to_consume(char, pattern); end - def position; end - def read; end - def scan(pattern, cons = nil); end - include REXML::Encoding -end -class REXML::IOSource < REXML::Source - def consume(pattern); end - def current_line; end - def empty?; end - def encoding_updated; end - def initialize(arg, block_size = nil, encoding = nil); end - def match(pattern, cons = nil); end - def position; end - def read; end - def readline; end - def scan(pattern, cons = nil); end -end -class REXML::Entity < REXML::Child - def external; end - def initialize(stream, value = nil, parent = nil, reference = nil); end - def name; end - def ndata; end - def normalized; end - def pubid; end - def ref; end - def self.matches?(string); end - def to_s; end - def unnormalized; end - def value; end - def write(out, indent = nil); end - include REXML::XMLTokens -end -module REXML::EntityConst -end -class REXML::AttlistDecl < REXML::Child - def [](key); end - def each(&block); end - def element_name; end - def include?(key); end - def initialize(source); end - def node_type; end - def write(out, indent = nil); end - include Enumerable -end -class REXML::ReferenceWriter - def initialize(id_type, public_id_literal, system_literal, context = nil); end - def write(output); end -end -class REXML::DocType < REXML::Parent - def add(child); end - def attribute_of(element, attribute); end - def attributes_of(element); end - def clone; end - def context; end - def entities; end - def entity(name); end - def external_id; end - def initialize(first, parent = nil); end - def name; end - def namespaces; end - def node_type; end - def notation(name); end - def notations; end - def public; end - def system; end - def write(output, indent = nil, transitive = nil, ie_hack = nil); end - include REXML::XMLTokens -end -class REXML::Declaration < REXML::Child - def initialize(src); end - def to_s; end - def write(output, indent); end -end -class REXML::ElementDecl < REXML::Declaration - def initialize(src); end -end -class REXML::ExternalEntity < REXML::Child - def initialize(src); end - def to_s; end - def write(output, indent); end -end -class REXML::NotationDecl < REXML::Child - def initialize(name, middle, pub, sys); end - def name; end - def public; end - def public=(arg0); end - def system; end - def system=(arg0); end - def to_s; end - def write(output, indent = nil); end -end -class REXML::Text < REXML::Child - def <<(to_append); end - def <=>(other); end - def clear_cache; end - def clone; end - def doctype; end - def empty?; end - def indent_text(string, level = nil, style = nil, indentfirstline = nil); end - def initialize(arg, respect_whitespace = nil, parent = nil, raw = nil, entity_filter = nil, illegal = nil); end - def inspect; end - def node_type; end - def parent=(parent); end - def raw; end - def raw=(arg0); end - def self.check(string, pattern, doctype); end - def self.expand(ref, doctype, filter); end - def self.normalize(input, doctype = nil, entity_filter = nil); end - def self.read_with_substitution(input, illegal = nil); end - def self.unnormalize(string, doctype = nil, filter = nil, illegal = nil); end - def to_s; end - def value; end - def value=(val); end - def wrap(string, width, addnewline = nil); end - def write(writer, indent = nil, transitive = nil, ie_hack = nil); end - def write_with_substitution(out, input); end - def xpath; end - include Comparable -end -class REXML::Attribute - def ==(other); end - def clone; end - def doctype; end - def element; end - def element=(element); end - def hash; end - def initialize(first, second = nil, parent = nil); end - def inspect; end - def namespace(arg = nil); end - def node_type; end - def normalized=(arg0); end - def prefix; end - def remove; end - def to_s; end - def to_string; end - def value; end - def write(output, indent = nil); end - def xpath; end - include REXML::Namespace - include REXML::Node -end -class REXML::CData < REXML::Text - def clone; end - def initialize(first, whitespace = nil, parent = nil); end - def to_s; end - def value; end - def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end -end -module REXML::Functions -end -module REXML::Parsers -end -class REXML::Parsers::XPathParser - def AdditiveExpr(path, parsed); end - def AndExpr(path, parsed); end - def EqualityExpr(path, parsed); end - def FilterExpr(path, parsed); end - def FunctionCall(rest, parsed); end - def LocationPath(path, parsed); end - def MultiplicativeExpr(path, parsed); end - def NodeTest(path, parsed); end - def OrExpr(path, parsed); end - def PathExpr(path, parsed); end - def Predicate(path, parsed); end - def PrimaryExpr(path, parsed); end - def RelationalExpr(path, parsed); end - def RelativeLocationPath(path, parsed); end - def UnaryExpr(path, parsed); end - def UnionExpr(path, parsed); end - def abbreviate(path); end - def expand(path); end - def get_group(string); end - def namespaces=(namespaces); end - def parse(path); end - def parse_args(string); end - def predicate(path); end - def predicate_to_string(path, &block); end - include REXML::XMLTokens -end -module REXML::DClonable -end -class REXML::XPathParser - def []=(variable_name, value); end - def child(nodeset); end - def compare(a, operator, b); end - def descendant(nodeset, include_self); end - def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end - def each_unnode(nodeset); end - def enter(tag, *args); end - def equality_relational_compare(set1, op, set2); end - def evaluate_predicate(expression, nodesets); end - def expr(path_stack, nodeset, context = nil); end - def filter_nodeset(nodeset); end - def first(path_stack, node); end - def following(node); end - def following_node_of(node); end - def get_first(path, nodeset); end - def get_namespace(node, prefix); end - def initialize(strict: nil); end - def leave(tag, *args); end - def match(path_stack, nodeset); end - def namespaces=(namespaces = nil); end - def next_sibling_node(node); end - def node_test(path_stack, nodesets, any_type: nil); end - def norm(b); end - def normalize_compare_values(a, operator, b); end - def parse(path, nodeset); end - def preceding(node); end - def preceding_node_of(node); end - def predicate(path, nodeset); end - def sort(array_of_nodes, order); end - def step(path_stack, any_type: nil, order: nil); end - def strict?; end - def trace(*args); end - def unnode(nodeset); end - def value_type(value); end - def variables=(vars = nil); end - include REXML::XMLTokens -end -class REXML::XPathNode - def context; end - def initialize(node, context = nil); end - def position; end - def raw_node; end -end -class REXML::XPath - def self.each(element, path = nil, namespaces = nil, variables = nil, options = nil, &block); end - def self.first(element, path = nil, namespaces = nil, variables = nil, options = nil); end - def self.match(element, path = nil, namespaces = nil, variables = nil, options = nil); end - include REXML::Functions -end -class REXML::Element < REXML::Parent - def [](name_or_index); end - def __to_xpath_helper(node); end - def add_attribute(key, value = nil); end - def add_attributes(hash); end - def add_element(element, attrs = nil); end - def add_namespace(prefix, uri = nil); end - def add_text(text); end - def attribute(name, namespace = nil); end - def attributes; end - def cdatas; end - def clone; end - def comments; end - def context; end - def context=(arg0); end - def delete_attribute(key); end - def delete_element(element); end - def delete_namespace(namespace = nil); end - def document; end - def each_element(xpath = nil, &block); end - def each_element_with_attribute(key, value = nil, max = nil, name = nil, &block); end - def each_element_with_text(text = nil, max = nil, name = nil, &block); end - def each_with_something(test, max = nil, name = nil); end - def elements; end - def get_elements(xpath); end - def get_text(path = nil); end - def has_attributes?; end - def has_elements?; end - def has_text?; end - def ignore_whitespace_nodes; end - def initialize(arg = nil, parent = nil, context = nil); end - def inspect; end - def instructions; end - def namespace(prefix = nil); end - def namespaces; end - def next_element; end - def node_type; end - def prefixes; end - def previous_element; end - def raw; end - def root; end - def root_node; end - def text(path = nil); end - def text=(text); end - def texts; end - def whitespace; end - def write(output = nil, indent = nil, transitive = nil, ie_hack = nil); end - def xpath; end - include REXML::Namespace -end -class REXML::Elements - def <<(element = nil); end - def [](index, name = nil); end - def []=(index, element); end - def add(element = nil); end - def collect(xpath = nil); end - def delete(element); end - def delete_all(xpath); end - def each(xpath = nil); end - def empty?; end - def index(element); end - def initialize(parent); end - def inject(xpath = nil, initial = nil); end - def literalize(name); end - def parent; end - def size; end - def to_a(xpath = nil); end - include Enumerable -end -class REXML::Attributes < Hash - def <<(attribute); end - def [](name); end - def []=(name, value); end - def add(attribute); end - def delete(attribute); end - def delete_all(name); end - def each; end - def each_attribute; end - def get_attribute(name); end - def get_attribute_ns(namespace, name); end - def initialize(element); end - def length; end - def namespaces; end - def prefixes; end - def size; end - def to_a; end -end -class REXML::XMLDecl < REXML::Child - def ==(other); end - def clone; end - def content(enc); end - def dowrite; end - def encoding=(enc); end - def initialize(version = nil, encoding = nil, standalone = nil); end - def inspect; end - def node_type; end - def nowrite; end - def old_enc=(encoding); end - def self.default; end - def stand_alone?; end - def standalone; end - def standalone=(arg0); end - def version; end - def version=(arg0); end - def write(writer, indent = nil, transitive = nil, ie_hack = nil); end - def writeencoding; end - def writethis; end - def xmldecl(version, encoding, standalone); end - include REXML::Encoding -end -class REXML::Comment < REXML::Child - def <=>(other); end - def ==(other); end - def clone; end - def initialize(first, second = nil); end - def node_type; end - def string; end - def string=(arg0); end - def to_s; end - def write(output, indent = nil, transitive = nil, ie_hack = nil); end - include Comparable -end -class REXML::Instruction < REXML::Child - def ==(other); end - def clone; end - def content; end - def content=(arg0); end - def initialize(target, content = nil); end - def inspect; end - def node_type; end - def target; end - def target=(arg0); end - def write(writer, indent = nil, transitive = nil, ie_hack = nil); end -end -class REXML::Output - def <<(content); end - def encoding; end - def initialize(real_IO, encd = nil); end - def to_s; end - include REXML::Encoding -end -class REXML::UndefinedNamespaceException < REXML::ParseException - def initialize(prefix, source, parser); end -end -class REXML::Parsers::BaseParser - def add_listener(listener); end - def empty?; end - def entity(reference, entities); end - def has_next?; end - def initialize(source); end - def need_source_encoding_update?(xml_declaration_encoding); end - def normalize(input, entities = nil, entity_filter = nil); end - def parse_attributes(prefixes, curr_ns); end - def parse_id(base_error_message, accept_external_id:, accept_public_id:); end - def parse_id_invalid_details(accept_external_id:, accept_public_id:); end - def parse_name(base_error_message); end - def peek(depth = nil); end - def position; end - def process_instruction; end - def pull; end - def pull_event; end - def source; end - def stream=(source); end - def unnormalize(string, entities = nil, filter = nil); end - def unshift(token); end -end -class REXML::Parsers::StreamParser - def add_listener(listener); end - def initialize(source, listener); end - def parse; end -end -module REXML::Validation -end -class REXML::Validation::ValidationException < RuntimeError - def initialize(msg); end -end -class REXML::Parsers::TreeParser - def add_listener(listener); end - def initialize(source, build_context = nil); end - def parse; end -end -class REXML::Document < REXML::Element - def <<(child); end - def add(child); end - def add_element(arg = nil, arg2 = nil); end - def build(source); end - def clone; end - def doctype; end - def document; end - def encoding; end - def entity_expansion_count; end - def expanded_name; end - def initialize(source = nil, context = nil); end - def name; end - def node_type; end - def record_entity_expansion; end - def root; end - def self.entity_expansion_limit; end - def self.entity_expansion_limit=(val); end - def self.entity_expansion_text_limit; end - def self.entity_expansion_text_limit=(val); end - def self.parse_stream(source, listener); end - def stand_alone?; end - def version; end - def write(*arguments); end - def xml_decl; end -end -module REXML::StreamListener - def attlistdecl(element_name, attributes, raw_content); end - def cdata(content); end - def comment(comment); end - def doctype(name, pub_sys, long_name, uri); end - def doctype_end; end - def elementdecl(content); end - def entity(content); end - def entitydecl(content); end - def instruction(name, instruction); end - def notationdecl(content); end - def tag_end(name); end - def tag_start(name, attrs); end - def text(text); end - def xmldecl(version, encoding, standalone); end -end diff --git a/sorbet/rbi/gems/rexml@3.2.5.rbi b/sorbet/rbi/gems/rexml@3.2.5.rbi new file mode 100644 index 00000000..42bc532d --- /dev/null +++ b/sorbet/rbi/gems/rexml@3.2.5.rbi @@ -0,0 +1,4714 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rexml` gem. +# Please instead update this file by running `bin/tapioca gem rexml`. + +# This class needs: +# * Documentation +# * Work! Not all types of attlists are intelligently parsed, so we just +# spew back out what we get in. This works, but it would be better if +# we formatted the output ourselves. +# +# AttlistDecls provide *just* enough support to allow namespace +# declarations. If you need some sort of generalized support, or have an +# interesting idea about how to map the hideous, terrible design of DTD +# AttlistDecls onto an intuitive Ruby interface, let me know. I'm desperate +# for anything to make DTDs more palateable. +# +# source://rexml-3.2.5/lib/rexml/attlistdecl.rb:18 +class REXML::AttlistDecl < ::REXML::Child + include ::Enumerable + + # Create an AttlistDecl, pulling the information from a Source. Notice + # that this isn't very convenient; to create an AttlistDecl, you basically + # have to format it yourself, and then have the initializer parse it. + # Sorry, but for the foreseeable future, DTD support in REXML is pretty + # weak on convenience. Have I mentioned how much I hate DTDs? + # + # @return [AttlistDecl] a new instance of AttlistDecl + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:29 + def initialize(source); end + + # Access the attlist attribute/value pairs. + # value = attlist_decl[ attribute_name ] + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:38 + def [](key); end + + # Iterate over the key/value pairs: + # attlist_decl.each { |attribute_name, attribute_value| ... } + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:50 + def each(&block); end + + # What is this? Got me. + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:22 + def element_name; end + + # Whether an attlist declaration includes the given attribute definition + # if attlist_decl.include? "xmlns:foobar" + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:44 + def include?(key); end + + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:59 + def node_type; end + + # Write out exactly what we got in. + # + # source://rexml-3.2.5/lib/rexml/attlistdecl.rb:55 + def write(out, indent = T.unsafe(nil)); end +end + +# Defines an Element Attribute; IE, a attribute=value pair, as in: +# . Attributes can be in their own +# namespaces. General users of REXML will not interact with the +# Attribute class much. +# +# source://rexml-3.2.5/lib/rexml/attribute.rb:10 +class REXML::Attribute + include ::REXML::Node + include ::REXML::XMLTokens + include ::REXML::Namespace + + # Constructor. + # FIXME: The parser doesn't catch illegal characters in attributes + # + # first:: + # Either: an Attribute, which this new attribute will become a + # clone of; or a String, which is the name of this attribute + # second:: + # If +first+ is an Attribute, then this may be an Element, or nil. + # If nil, then the Element parent of this attribute is the parent + # of the +first+ Attribute. If the first argument is a String, + # then this must also be a String, and is the content of the attribute. + # If this is the content, it must be fully normalized (contain no + # illegal characters). + # parent:: + # Ignored unless +first+ is a String; otherwise, may be the Element + # parent of this attribute, or nil. + # + # + # Attribute.new( attribute_to_clone ) + # Attribute.new( attribute_to_clone, parent_element ) + # Attribute.new( "attr", "attr_value" ) + # Attribute.new( "attr", "attr_value", parent_element ) + # + # @return [Attribute] a new instance of Attribute + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:45 + def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end + + # Returns true if other is an Attribute and has the same name and value, + # false otherwise. + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:109 + def ==(other); end + + # Returns a copy of this attribute + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:158 + def clone; end + + # source://rexml-3.2.5/lib/rexml/attribute.rb:132 + def doctype; end + + # The element to which this attribute belongs + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:15 + def element; end + + # Sets the element of which this object is an attribute. Normally, this + # is not directly called. + # + # Returns this attribute + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:166 + def element=(element); end + + # Creates (and returns) a hash from both the name and value + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:114 + def hash; end + + # source://rexml-3.2.5/lib/rexml/attribute.rb:192 + def inspect; end + + # Returns the namespace URL, if defined, or nil otherwise + # + # e = Element.new("el") + # e.add_namespace("ns", "http://url") + # e.add_attribute("ns:a", "b") + # e.add_attribute("nsx:a", "c") + # e.attribute("ns:a").namespace # => "http://url" + # e.attribute("nsx:a").namespace # => nil + # + # This method always returns "" for no namespace attribute. Because + # the default namespace doesn't apply to attribute names. + # + # From https://www.w3.org/TR/xml-names/#uniqAttrs + # + # > the default namespace does not apply to attribute names + # + # e = REXML::Element.new("el") + # e.add_namespace("", "http://example.com/") + # e.namespace # => "http://example.com/" + # e.add_attribute("a", "b") + # e.attribute("a").namespace # => "" + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:98 + def namespace(arg = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/attribute.rb:188 + def node_type; end + + # The normalized value of this attribute. That is, the attribute with + # entities intact. + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:18 + def normalized=(_arg0); end + + # Returns the namespace of the attribute. + # + # e = Element.new( "elns:myelement" ) + # e.add_attribute( "nsa:a", "aval" ) + # e.add_attribute( "b", "bval" ) + # e.attributes.get_attribute( "a" ).prefix # -> "nsa" + # e.attributes.get_attribute( "b" ).prefix # -> "" + # a = Attribute.new( "x", "y" ) + # a.prefix # -> "" + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:73 + def prefix; end + + # Removes this Attribute from the tree, and returns true if successful + # + # This method is usually not called directly. + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:179 + def remove; end + + # Returns the attribute value, with entities replaced + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:140 + def to_s; end + + # Returns this attribute out as XML source, expanding the name + # + # a = Attribute.new( "x", "y" ) + # a.to_string # -> "x='y'" + # b = Attribute.new( "ns:x", "y" ) + # b.to_string # -> "ns:x='y'" + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:124 + def to_string; end + + # Returns the UNNORMALIZED value of this attribute. That is, entities + # have been expanded to their values + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:150 + def value; end + + # Writes this attribute (EG, puts 'key="value"' to the output) + # + # source://rexml-3.2.5/lib/rexml/attribute.rb:184 + def write(output, indent = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/attribute.rb:198 + def xpath; end +end + +# A class that defines the set of Attributes of an Element and provides +# operations for accessing elements in that set. +# +# source://rexml-3.2.5/lib/rexml/element.rb:2141 +class REXML::Attributes < ::Hash + # :call-seq: + # new(element) + # + # Creates and returns a new \REXML::Attributes object. + # The element given by argument +element+ is stored, + # but its own attributes are not modified: + # + # ele = REXML::Element.new('foo') + # attrs = REXML::Attributes.new(ele) + # attrs.object_id == ele.attributes.object_id # => false + # + # Other instance methods in class \REXML::Attributes may refer to: + # + # - +element.document+. + # - +element.prefix+. + # - +element.expanded_name+. + # + # @return [Attributes] a new instance of Attributes + # + # source://rexml-3.2.5/lib/rexml/element.rb:2160 + def initialize(element); end + + # :call-seq: + # add(attribute) -> attribute + # + # Adds attribute +attribute+, replacing the previous + # attribute of the same name if it exists; + # returns +attribute+: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs # => {"att"=>{"foo"=>foo:att='1', "bar"=>bar:att='2', ""=>att='<'}} + # attrs.add(REXML::Attribute.new('foo:att', '2')) # => foo:att='2' + # attrs.add(REXML::Attribute.new('baz', '3')) # => baz='3' + # attrs.include?('baz') # => true + # + # source://rexml-3.2.5/lib/rexml/element.rb:2537 + def <<(attribute); end + + # :call-seq: + # [name] -> attribute_value or nil + # + # Returns the value for the attribute given by +name+, + # if it exists; otherwise +nil+. + # The value returned is the unnormalized attribute value, + # with entities expanded: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.elements['//ele'] # => + # ele.attributes['att'] # => "<" + # ele.attributes['bar:att'] # => "2" + # ele.attributes['nosuch'] # => nil + # + # Related: get_attribute (returns an \Attribute object). + # + # source://rexml-3.2.5/lib/rexml/element.rb:2185 + def [](name); end + + # :call-seq: + # [name] = value -> value + # + # When +value+ is non-+nil+, + # assigns that to the attribute for the given +name+, + # overwriting the previous value if it exists: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs['foo:att'] = '2' # => "2" + # attrs['baz:att'] = '3' # => "3" + # + # When +value+ is +nil+, deletes the attribute if it exists: + # + # attrs['baz:att'] = nil + # attrs.include?('baz:att') # => false + # + # source://rexml-3.2.5/lib/rexml/element.rb:2369 + def []=(name, value); end + + # :call-seq: + # add(attribute) -> attribute + # + # Adds attribute +attribute+, replacing the previous + # attribute of the same name if it exists; + # returns +attribute+: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs # => {"att"=>{"foo"=>foo:att='1', "bar"=>bar:att='2', ""=>att='<'}} + # attrs.add(REXML::Attribute.new('foo:att', '2')) # => foo:att='2' + # attrs.add(REXML::Attribute.new('baz', '3')) # => baz='3' + # attrs.include?('baz') # => true + # + # source://rexml-3.2.5/lib/rexml/element.rb:2537 + def add(attribute); end + + # :call-seq: + # delete(name) -> element + # delete(attribute) -> element + # + # Removes a specified attribute if it exists; + # returns the attributes' element. + # + # When string argument +name+ is given, + # removes the attribute of that name if it exists: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs.delete('foo:att') # => + # attrs.delete('foo:att') # => + # + # When attribute argument +attribute+ is given, + # removes that attribute if it exists: + # + # attr = REXML::Attribute.new('bar:att', '2') + # attrs.delete(attr) # => # => + # attrs.delete(attr) # => # => + # + # source://rexml-3.2.5/lib/rexml/element.rb:2490 + def delete(attribute); end + + # :call-seq: + # delete_all(name) -> array_of_removed_attributes + # + # Removes all attributes matching the given +name+; + # returns an array of the removed attributes: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs.delete_all('att') # => [att='<'] + # + # source://rexml-3.2.5/lib/rexml/element.rb:2559 + def delete_all(name); end + + # :call-seq: + # each {|expanded_name, value| ... } + # + # Calls the given block with each expanded-name/value pair: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # ele.attributes.each do |expanded_name, value| + # p [expanded_name, value] + # end + # + # Output: + # + # ["foo:att", "1"] + # ["bar:att", "2"] + # ["att", "<"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:2287 + def each; end + + # :call-seq: + # each_attribute {|attr| ... } + # + # Calls the given block with each \REXML::Attribute object: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # ele.attributes.each_attribute do |attr| + # p [attr.class, attr] + # end + # + # Output: + # + # [REXML::Attribute, foo:att='1'] + # [REXML::Attribute, bar:att='2'] + # [REXML::Attribute, att='<'] + # + # source://rexml-3.2.5/lib/rexml/element.rb:2254 + def each_attribute; end + + # :call-seq: + # get_attribute(name) -> attribute_object or nil + # + # Returns the \REXML::Attribute object for the given +name+: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs.get_attribute('foo:att') # => foo:att='1' + # attrs.get_attribute('foo:att').class # => REXML::Attribute + # attrs.get_attribute('bar:att') # => bar:att='2' + # attrs.get_attribute('att') # => att='<' + # attrs.get_attribute('nosuch') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:2313 + def get_attribute(name); end + + # :call-seq: + # get_attribute_ns(namespace, name) + # + # Returns the \REXML::Attribute object among the attributes + # that matches the given +namespace+ and +name+: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes + # attrs.get_attribute_ns('http://foo', 'att') # => foo:att='1' + # attrs.get_attribute_ns('http://foo', 'nosuch') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:2585 + def get_attribute_ns(namespace, name); end + + # :call-seq: + # length + # + # Returns the count of attributes: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # ele.attributes.length # => 3 + # + # source://rexml-3.2.5/lib/rexml/element.rb:2225 + def length; end + + # :call-seq: + # namespaces + # + # Returns a hash of name/value pairs for the namespaces: + # + # xml_string = '' + # d = REXML::Document.new(xml_string) + # d.root.attributes.namespaces # => {"xmlns"=>"foo", "x"=>"bar", "y"=>"twee"} + # + # source://rexml-3.2.5/lib/rexml/element.rb:2446 + def namespaces; end + + # :call-seq: + # prefixes -> array_of_prefix_strings + # + # Returns an array of prefix strings in the attributes. + # The array does not include the default + # namespace declaration, if one exists. + # + # xml_string = '' + # d = REXML::Document.new(xml_string) + # d.root.attributes.prefixes # => ["x", "y"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:2421 + def prefixes; end + + # :call-seq: + # length + # + # Returns the count of attributes: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # ele.attributes.length # => 3 + # + # source://rexml-3.2.5/lib/rexml/element.rb:2225 + def size; end + + # :call-seq: + # to_a -> array_of_attribute_objects + # + # Returns an array of \REXML::Attribute objects representing + # the attributes: + # + # xml_string = <<-EOT + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # ele = d.root.elements['//ele'] # => + # attrs = ele.attributes.to_a # => [foo:att='1', bar:att='2', att='<'] + # attrs.first.class # => REXML::Attribute + # + # source://rexml-3.2.5/lib/rexml/element.rb:2207 + def to_a; end +end + +# source://rexml-3.2.5/lib/rexml/cdata.rb:5 +class REXML::CData < ::REXML::Text + # Constructor. CData is data between + # + # _Examples_ + # CData.new( source ) + # CData.new( "Here is some CDATA" ) + # CData.new( "Some unprocessed data", respect_whitespace_TF, parent_element ) + # + # @return [CData] a new instance of CData + # + # source://rexml-3.2.5/lib/rexml/cdata.rb:16 + def initialize(first, whitespace = T.unsafe(nil), parent = T.unsafe(nil)); end + + # Make a copy of this object + # + # _Examples_ + # c = CData.new( "Some text" ) + # d = c.clone + # d.to_s # -> "Some text" + # + # source://rexml-3.2.5/lib/rexml/cdata.rb:26 + def clone; end + + # Returns the content of this CData object + # + # _Examples_ + # c = CData.new( "Some text" ) + # c.to_s # -> "Some text" + # + # source://rexml-3.2.5/lib/rexml/cdata.rb:35 + def to_s; end + + # source://rexml-3.2.5/lib/rexml/cdata.rb:39 + def value; end + + # == DEPRECATED + # See the rexml/formatters package + # + # Generates XML output of this object + # + # output:: + # Where to write the string. Defaults to $stdout + # indent:: + # The amount to indent this node by + # transitive:: + # Ignored + # ie_hack:: + # Ignored + # + # _Examples_ + # c = CData.new( " Some text " ) + # c.write( $stdout ) #-> + # + # source://rexml-3.2.5/lib/rexml/cdata.rb:60 + def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end +end + +# A Child object is something contained by a parent, and this class +# contains methods to support that. Most user code will not use this +# class directly. +# +# source://rexml-3.2.5/lib/rexml/child.rb:9 +class REXML::Child + include ::REXML::Node + + # Constructor. Any inheritors of this class should call super to make + # sure this method is called. + # parent:: + # if supplied, the parent of this child will be set to the + # supplied value, and self will be added to the parent + # + # @return [Child] a new instance of Child + # + # source://rexml-3.2.5/lib/rexml/child.rb:18 + def initialize(parent = T.unsafe(nil)); end + + # This doesn't yet handle encodings + # + # source://rexml-3.2.5/lib/rexml/child.rb:91 + def bytes; end + + # Returns:: the document this child belongs to, or nil if this child + # belongs to no document + # + # source://rexml-3.2.5/lib/rexml/child.rb:85 + def document; end + + # source://rexml-3.2.5/lib/rexml/node.rb:11 + def next_sibling; end + + # Sets the next sibling of this child. This can be used to insert a child + # after some other child. + # a = Element.new("a") + # b = a.add_element("b") + # c = Element.new("c") + # b.next_sibling = c + # # => + # + # source://rexml-3.2.5/lib/rexml/child.rb:68 + def next_sibling=(other); end + + # The Parent of this object + # + # source://rexml-3.2.5/lib/rexml/child.rb:11 + def parent; end + + # Sets the parent of this child to the supplied argument. + # + # other:: + # Must be a Parent object. If this object is the same object as the + # existing parent of this child, no action is taken. Otherwise, this + # child is removed from the current parent (if one exists), and is added + # to the new parent. + # Returns:: The parent added + # + # source://rexml-3.2.5/lib/rexml/child.rb:52 + def parent=(other); end + + # source://rexml-3.2.5/lib/rexml/node.rb:17 + def previous_sibling; end + + # Sets the previous sibling of this child. This can be used to insert a + # child before some other child. + # a = Element.new("a") + # b = a.add_element("b") + # c = Element.new("c") + # b.previous_sibling = c + # # => + # + # source://rexml-3.2.5/lib/rexml/child.rb:79 + def previous_sibling=(other); end + + # Removes this child from the parent. + # + # Returns:: self + # + # source://rexml-3.2.5/lib/rexml/child.rb:37 + def remove; end + + # Replaces this object with another object. Basically, calls + # Parent.replace_child + # + # Returns:: self + # + # source://rexml-3.2.5/lib/rexml/child.rb:29 + def replace_with(child); end +end + +# Represents an XML comment; that is, text between \ +# +# source://rexml-3.2.5/lib/rexml/comment.rb:7 +class REXML::Comment < ::REXML::Child + include ::Comparable + + # Constructor. The first argument can be one of three types: + # argument. If Comment, the argument is duplicated. If + # Source, the argument is scanned for a comment. + # should be nil, not supplied, or a Parent to be set as the parent + # of this object + # + # @param first If String, the contents of this comment are set to the + # @param second If the first argument is a Source, this argument + # @return [Comment] a new instance of Comment + # + # source://rexml-3.2.5/lib/rexml/comment.rb:24 + def initialize(first, second = T.unsafe(nil)); end + + # Compares this Comment to another; the contents of the comment are used + # in the comparison. + # + # source://rexml-3.2.5/lib/rexml/comment.rb:63 + def <=>(other); end + + # Compares this Comment to another; the contents of the comment are used + # in the comparison. + # + # source://rexml-3.2.5/lib/rexml/comment.rb:70 + def ==(other); end + + # source://rexml-3.2.5/lib/rexml/comment.rb:33 + def clone; end + + # source://rexml-3.2.5/lib/rexml/comment.rb:75 + def node_type; end + + # The content text + # + # source://rexml-3.2.5/lib/rexml/comment.rb:14 + def string; end + + # The content text + # + # source://rexml-3.2.5/lib/rexml/comment.rb:14 + def string=(_arg0); end + + # The content text + # + # source://rexml-3.2.5/lib/rexml/comment.rb:14 + def to_s; end + + # == DEPRECATED + # See REXML::Formatters + # + # output:: + # Where to write the string + # indent:: + # An integer. If -1, no indenting will be used; otherwise, the + # indentation will be this number of spaces, and children will be + # indented an additional amount. + # transitive:: + # Ignored by this class. The contents of comments are never modified. + # ie_hack:: + # Needed for conformity to the child API, but not used by this class. + # + # source://rexml-3.2.5/lib/rexml/comment.rb:50 + def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end +end + +# source://rexml-3.2.5/lib/rexml/xpath_parser.rb:11 +module REXML::DClonable; end + +# This is an abstract class. You never use this directly; it serves as a +# parent class for the specific declarations. +# +# source://rexml-3.2.5/lib/rexml/doctype.rb:242 +class REXML::Declaration < ::REXML::Child + # @return [Declaration] a new instance of Declaration + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:243 + def initialize(src); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:248 + def to_s; end + + # == DEPRECATED + # See REXML::Formatters + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:255 + def write(output, indent); end +end + +# Represents an XML DOCTYPE declaration; that is, the contents of . DOCTYPES can be used to declare the DTD of a document, as well as +# being used to declare entities used in the document. +# +# source://rexml-3.2.5/lib/rexml/doctype.rb:51 +class REXML::DocType < ::REXML::Parent + include ::REXML::XMLTokens + + # Constructor + # + # dt = DocType.new( 'foo', '-//I/Hate/External/IDs' ) + # # + # dt = DocType.new( doctype_to_clone ) + # # Incomplete. Shallow clone of doctype + # + # +Note+ that the constructor: + # + # Doctype.new( Source.new( "" ) ) + # + # is _deprecated_. Do not use it. It will probably disappear. + # + # @return [DocType] a new instance of DocType + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:80 + def initialize(first, parent = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:185 + def add(child); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:125 + def attribute_of(element, attribute); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:115 + def attributes_of(element); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:135 + def clone; end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:173 + def context; end + + # name is the name of the doctype + # external_id is the referenced DTD, if given + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:66 + def entities; end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:181 + def entity(name); end + + # name is the name of the doctype + # external_id is the referenced DTD, if given + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:66 + def external_id; end + + # name is the name of the doctype + # external_id is the referenced DTD, if given + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:66 + def name; end + + # name is the name of the doctype + # external_id is the referenced DTD, if given + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:66 + def namespaces; end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:111 + def node_type; end + + # Retrieves a named notation. Only notations declared in the internal + # DTD subset can be retrieved. + # + # Method contributed by Henrik Martensson + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:229 + def notation(name); end + + # This method returns a list of notations that have been declared in the + # _internal_ DTD subset. Notations in the external DTD subset are not + # listed. + # + # Method contributed by Henrik Martensson + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:221 + def notations; end + + # This method retrieves the public identifier identifying the document's + # DTD. + # + # Method contributed by Henrik Martensson + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:195 + def public; end + + # This method retrieves the system identifier identifying the document's DTD + # + # Method contributed by Henrik Martensson + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:207 + def system; end + + # output:: + # Where to write the string + # indent:: + # An integer. If -1, no indentation will be used; otherwise, the + # indentation will be this number of spaces, and children will be + # indented an additional amount. + # transitive:: + # Ignored + # ie_hack:: + # Ignored + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:149 + def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end +end + +# Represents an XML document. +# +# A document may have: +# +# - A single child that may be accessed via method #root. +# - An XML declaration. +# - A document type. +# - Processing instructions. +# +# == In a Hurry? +# +# If you're somewhat familiar with XML +# and have a particular task in mind, +# you may want to see the +# {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html], +# and in particular, the +# {tasks page for documents}[../doc/rexml/tasks/tocs/document_toc_rdoc.html]. +# +# source://rexml-3.2.5/lib/rexml/document.rb:39 +class REXML::Document < ::REXML::Element + # :call-seq: + # new(string = nil, context = {}) -> new_document + # new(io_stream = nil, context = {}) -> new_document + # new(document = nil, context = {}) -> new_document + # + # Returns a new \REXML::Document object. + # + # When no arguments are given, + # returns an empty document: + # + # d = REXML::Document.new + # d.to_s # => "" + # + # When argument +string+ is given, it must be a string + # containing a valid XML document: + # + # xml_string = 'FooBar' + # d = REXML::Document.new(xml_string) + # d.to_s # => "FooBar" + # + # When argument +io_stream+ is given, it must be an \IO object + # that is opened for reading, and when read must return a valid XML document: + # + # File.write('t.xml', xml_string) + # d = File.open('t.xml', 'r') do |io| + # REXML::Document.new(io) + # end + # d.to_s # => "FooBar" + # + # When argument +document+ is given, it must be an existing + # document object, whose context and attributes (but not chidren) + # are cloned into the new document: + # + # d = REXML::Document.new(xml_string) + # d.children # => [ ... ] + # d.context = {raw: :all, compress_whitespace: :all} + # d.add_attributes({'bar' => 0, 'baz' => 1}) + # d1 = REXML::Document.new(d) + # d1.children # => [] + # d1.context # => {:raw=>:all, :compress_whitespace=>:all} + # d1.attributes # => {"bar"=>bar='0', "baz"=>baz='1'} + # + # When argument +context+ is given, it must be a hash + # containing context entries for the document; + # see {Element Context}[../doc/rexml/context_rdoc.html]: + # + # context = {raw: :all, compress_whitespace: :all} + # d = REXML::Document.new(xml_string, context) + # d.context # => {:raw=>:all, :compress_whitespace=>:all} + # + # @return [Document] a new instance of Document + # + # source://rexml-3.2.5/lib/rexml/document.rb:92 + def initialize(source = T.unsafe(nil), context = T.unsafe(nil)); end + + # :call-seq: + # add(xml_decl) -> self + # add(doc_type) -> self + # add(object) -> self + # + # Adds an object to the document; returns +self+. + # + # When argument +xml_decl+ is given, + # it must be an REXML::XMLDecl object, + # which becomes the XML declaration for the document, + # replacing the previous XML declaration if any: + # + # d = REXML::Document.new + # d.xml_decl.to_s # => "" + # d.add(REXML::XMLDecl.new('2.0')) + # d.xml_decl.to_s # => "" + # + # When argument +doc_type+ is given, + # it must be an REXML::DocType object, + # which becomes the document type for the document, + # replacing the previous document type, if any: + # + # d = REXML::Document.new + # d.doctype.to_s # => "" + # d.add(REXML::DocType.new('foo')) + # d.doctype.to_s # => "" + # + # When argument +object+ (not an REXML::XMLDecl or REXML::DocType object) + # is given it is added as the last child: + # + # d = REXML::Document.new + # d.add(REXML::Element.new('foo')) + # d.to_s # => "" + # + # source://rexml-3.2.5/lib/rexml/document.rb:170 + def <<(child); end + + # :call-seq: + # add(xml_decl) -> self + # add(doc_type) -> self + # add(object) -> self + # + # Adds an object to the document; returns +self+. + # + # When argument +xml_decl+ is given, + # it must be an REXML::XMLDecl object, + # which becomes the XML declaration for the document, + # replacing the previous XML declaration if any: + # + # d = REXML::Document.new + # d.xml_decl.to_s # => "" + # d.add(REXML::XMLDecl.new('2.0')) + # d.xml_decl.to_s # => "" + # + # When argument +doc_type+ is given, + # it must be an REXML::DocType object, + # which becomes the document type for the document, + # replacing the previous document type, if any: + # + # d = REXML::Document.new + # d.doctype.to_s # => "" + # d.add(REXML::DocType.new('foo')) + # d.doctype.to_s # => "" + # + # When argument +object+ (not an REXML::XMLDecl or REXML::DocType object) + # is given it is added as the last child: + # + # d = REXML::Document.new + # d.add(REXML::Element.new('foo')) + # d.to_s # => "" + # + # source://rexml-3.2.5/lib/rexml/document.rb:170 + def add(child); end + + # :call-seq: + # add_element(name_or_element = nil, attributes = nil) -> new_element + # + # Adds an element to the document by calling REXML::Element.add_element: + # + # REXML::Element.add_element(name_or_element, attributes) + # + # source://rexml-3.2.5/lib/rexml/document.rb:209 + def add_element(arg = T.unsafe(nil), arg2 = T.unsafe(nil)); end + + # :call-seq: + # clone -> new_document + # + # Returns the new document resulting from executing + # Document.new(self). See Document.new. + # + # source://rexml-3.2.5/lib/rexml/document.rb:120 + def clone; end + + # :call-seq: + # doctype -> doc_type or nil + # + # Returns the DocType object for the document, if it exists, otherwise +nil+: + # + # d = REXML::Document.new('') + # d.doctype.class # => REXML::DocType + # d = REXML::Document.new('') + # d.doctype.class # => nil + # + # source://rexml-3.2.5/lib/rexml/document.rb:241 + def doctype; end + + # source://rexml-3.2.5/lib/rexml/document.rb:442 + def document; end + + # :call-seq: + # encoding -> encoding_string + # + # Returns the XMLDecl encoding of the document, + # + # d = REXML::Document.new('') + # d.encoding # => "UTF-16" + # d = REXML::Document.new('') + # d.encoding # => "UTF-8" + # + # source://rexml-3.2.5/lib/rexml/document.rb:290 + def encoding; end + + # Returns the value of attribute entity_expansion_count. + # + # source://rexml-3.2.5/lib/rexml/document.rb:433 + def entity_expansion_count; end + + # :call-seq: + # expanded_name -> empty_string + # + # Returns an empty string. + # + # source://rexml-3.2.5/lib/rexml/document.rb:129 + def expanded_name; end + + # :call-seq: + # expanded_name -> empty_string + # + # Returns an empty string. + # d = doc_type + # d ? d.name : "UNDEFINED" + # + # source://rexml-3.2.5/lib/rexml/document.rb:129 + def name; end + + # :call-seq: + # node_type -> :document + # + # Returns the symbol +:document+. + # + # source://rexml-3.2.5/lib/rexml/document.rb:110 + def node_type; end + + # source://rexml-3.2.5/lib/rexml/document.rb:435 + def record_entity_expansion; end + + # :call-seq: + # root -> root_element or nil + # + # Returns the root element of the document, if it exists, otherwise +nil+: + # + # d = REXML::Document.new('') + # d.root # => + # d = REXML::Document.new('') + # d.root # => nil + # + # source://rexml-3.2.5/lib/rexml/document.rb:225 + def root; end + + # :call-seq: + # stand_alone? + # + # Returns the XMLDecl standalone value of the document as a string, + # if it has been set, otherwise the default standalone value: + # + # d = REXML::Document.new('') + # d.stand_alone? # => "yes" + # d = REXML::Document.new('') + # d.stand_alone? # => nil + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/document.rb:305 + def stand_alone?; end + + # :call-seq: + # version -> version_string + # + # Returns the XMLDecl version of this document as a string, + # if it has been set, otherwise the default version: + # + # d = REXML::Document.new('') + # d.version # => "2.0" + # d = REXML::Document.new('') + # d.version # => "1.0" + # + # source://rexml-3.2.5/lib/rexml/document.rb:275 + def version; end + + # :call-seq: + # doc.write(output=$stdout, indent=-1, transtive=false, ie_hack=false, encoding=nil) + # doc.write(options={:output => $stdout, :indent => -1, :transtive => false, :ie_hack => false, :encoding => nil}) + # + # Write the XML tree out, optionally with indent. This writes out the + # entire XML document, including XML declarations, doctype declarations, + # and processing instructions (if any are given). + # + # A controversial point is whether Document should always write the XML + # declaration () whether or not one is given by the + # user (or source document). REXML does not write one if one was not + # specified, because it adds unnecessary bandwidth to applications such + # as XML-RPC. + # + # Accept Nth argument style and options Hash style as argument. + # The recommended style is options Hash style for one or more + # arguments case. + # + # _Examples_ + # Document.new("").write + # + # output = "" + # Document.new("").write(output) + # + # output = "" + # Document.new("").write(:output => output, :indent => 2) + # + # See also the classes in the rexml/formatters package for the proper way + # to change the default formatting of XML output. + # + # _Examples_ + # + # output = "" + # tr = Transitive.new + # tr.write(Document.new(""), output) + # + # output:: + # output an object which supports '<< string'; this is where the + # document will be written. + # indent:: + # An integer. If -1, no indenting will be used; otherwise, the + # indentation will be twice this number of spaces, and children will be + # indented an additional amount. For a value of 3, every item will be + # indented 3 more levels, or 6 more spaces (2 * 3). Defaults to -1 + # transitive:: + # If transitive is true and indent is >= 0, then the output will be + # pretty-printed in such a way that the added whitespace does not affect + # the absolute *value* of the document -- that is, it leaves the value + # and number of Text nodes in the document unchanged. + # ie_hack:: + # This hack inserts a space before the /> on empty tags to address + # a limitation of Internet Explorer. Defaults to false + # Encoding name as String. Change output encoding to specified encoding + # instead of encoding in XML declaration. + # Defaults to nil. It means encoding in XML declaration is used. + # + # source://rexml-3.2.5/lib/rexml/document.rb:365 + def write(*arguments); end + + # :call-seq: + # xml_decl -> xml_decl + # + # Returns the XMLDecl object for the document, if it exists, + # otherwise the default XMLDecl object: + # + # d = REXML::Document.new('') + # d.xml_decl.class # => REXML::XMLDecl + # d.xml_decl.to_s # => "" + # d = REXML::Document.new('') + # d.xml_decl.class # => REXML::XMLDecl + # d.xml_decl.to_s # => "" + # + # source://rexml-3.2.5/lib/rexml/document.rb:258 + def xml_decl; end + + private + + # source://rexml-3.2.5/lib/rexml/document.rb:447 + def build(source); end + + class << self + # Get the entity expansion limit. By default the limit is set to 10000. + # + # Deprecated. Use REXML::Security.entity_expansion_limit= instead. + # + # source://rexml-3.2.5/lib/rexml/document.rb:415 + def entity_expansion_limit; end + + # Set the entity expansion limit. By default the limit is set to 10000. + # + # Deprecated. Use REXML::Security.entity_expansion_limit= instead. + # + # source://rexml-3.2.5/lib/rexml/document.rb:408 + def entity_expansion_limit=(val); end + + # Get the entity expansion limit. By default the limit is set to 10240. + # + # Deprecated. Use REXML::Security.entity_expansion_text_limit instead. + # + # source://rexml-3.2.5/lib/rexml/document.rb:429 + def entity_expansion_text_limit; end + + # Set the entity expansion limit. By default the limit is set to 10240. + # + # Deprecated. Use REXML::Security.entity_expansion_text_limit= instead. + # + # source://rexml-3.2.5/lib/rexml/document.rb:422 + def entity_expansion_text_limit=(val); end + + # source://rexml-3.2.5/lib/rexml/document.rb:401 + def parse_stream(source, listener); end + end +end + +# An \REXML::Element object represents an XML element. +# +# An element: +# +# - Has a name (string). +# - May have a parent (another element). +# - Has zero or more children +# (other elements, text, CDATA, processing instructions, and comments). +# - Has zero or more siblings +# (other elements, text, CDATA, processing instructions, and comments). +# - Has zero or more named attributes. +# +# == In a Hurry? +# +# If you're somewhat familiar with XML +# and have a particular task in mind, +# you may want to see the +# {tasks pages}[../doc/rexml/tasks/tocs/master_toc_rdoc.html], +# and in particular, the +# {tasks page for elements}[../doc/rexml/tasks/tocs/element_toc_rdoc.html]. +# +# === Name +# +# An element has a name, which is initially set when the element is created: +# +# e = REXML::Element.new('foo') +# e.name # => "foo" +# +# The name may be changed: +# +# e.name = 'bar' +# e.name # => "bar" +# +# +# === \Parent +# +# An element may have a parent. +# +# Its parent may be assigned explicitly when the element is created: +# +# e0 = REXML::Element.new('foo') +# e1 = REXML::Element.new('bar', e0) +# e1.parent # => ... +# +# Note: the representation of an element always shows the element's name. +# If the element has children, the representation indicates that +# by including an ellipsis (...). +# +# The parent may be assigned explicitly at any time: +# +# e2 = REXML::Element.new('baz') +# e1.parent = e2 +# e1.parent # => +# +# When an element is added as a child, its parent is set automatically: +# +# e1.add_element(e0) +# e0.parent # => ... +# +# For an element that has no parent, method +parent+ returns +nil+. +# +# === Children +# +# An element has zero or more children. +# The children are an ordered collection +# of all objects whose parent is the element itself. +# +# The children may include any combination of elements, text, comments, +# processing instructions, and CDATA. +# (This example keeps things clean by controlling whitespace +# via a +context+ setting.) +# +# xml_string = <<-EOT +# +# +# text 0 +# +# +# +# +# text 1 +# +# +# +# +# EOT +# context = {ignore_whitespace_nodes: :all, compress_whitespace: :all} +# d = REXML::Document.new(xml_string, context) +# root = d.root +# root.children.size # => 10 +# root.each {|child| p "#{child.class}: #{child}" } +# +# Output: +# +# "REXML::Element: " +# "REXML::Text: \n text 0\n " +# "REXML::Comment: comment 0" +# "REXML::Instruction: " +# "REXML::CData: cdata 0" +# "REXML::Element: " +# "REXML::Text: \n text 1\n " +# "REXML::Comment: comment 1" +# "REXML::Instruction: " +# "REXML::CData: cdata 1" +# +# A child may be added using inherited methods +# Parent#insert_before or Parent#insert_after: +# +# xml_string = '' +# d = REXML::Document.new(xml_string) +# root = d.root +# c = d.root[1] # => +# root.insert_before(c, REXML::Element.new('b')) +# root.to_a # => [, , , ] +# +# A child may be replaced using Parent#replace_child: +# +# root.replace_child(c, REXML::Element.new('x')) +# root.to_a # => [, , , ] +# +# A child may be removed using Parent#delete: +# +# x = root[2] # => +# root.delete(x) +# root.to_a # => [, , ] +# +# === Siblings +# +# An element has zero or more siblings, +# which are the other children of the element's parent. +# +# In the example above, element +ele_1+ is between a CDATA sibling +# and a text sibling: +# +# ele_1 = root[5] # => +# ele_1.previous_sibling # => "cdata 0" +# ele_1.next_sibling # => "\n text 1\n " +# +# === \Attributes +# +# An element has zero or more named attributes. +# +# A new element has no attributes: +# +# e = REXML::Element.new('foo') +# e.attributes # => {} +# +# Attributes may be added: +# +# e.add_attribute('bar', 'baz') +# e.add_attribute('bat', 'bam') +# e.attributes.size # => 2 +# e['bar'] # => "baz" +# e['bat'] # => "bam" +# +# An existing attribute may be modified: +# +# e.add_attribute('bar', 'bad') +# e.attributes.size # => 2 +# e['bar'] # => "bad" +# +# An existing attribute may be deleted: +# +# e.delete_attribute('bar') +# e.attributes.size # => 1 +# e['bar'] # => nil +# +# == What's Here +# +# To begin with, what's elsewhere? +# +# \Class \REXML::Element inherits from its ancestor classes: +# +# - REXML::Child +# - REXML::Parent +# +# \REXML::Element itself and its ancestors also include modules: +# +# - {Enumerable}[https://docs.ruby-lang.org/en/master/Enumerable.html] +# - REXML::Namespace +# - REXML::Node +# - REXML::XMLTokens +# +# === Methods for Creating an \Element +# +# ::new:: Returns a new empty element. +# #clone:: Returns a clone of another element. +# +# === Methods for Attributes +# +# {[attribute_name]}[#method-i-5B-5D]:: Returns an attribute value. +# #add_attribute:: Adds a new attribute. +# #add_attributes:: Adds multiple new attributes. +# #attribute:: Returns the attribute value for a given name and optional namespace. +# #delete_attribute:: Removes an attribute. +# +# === Methods for Children +# +# {[index]}[#method-i-5B-5D]:: Returns the child at the given offset. +# #add_element:: Adds an element as the last child. +# #delete_element:: Deletes a child element. +# #each_element:: Calls the given block with each child element. +# #each_element_with_attribute:: Calls the given block with each child element +# that meets given criteria, +# which can include the attribute name. +# #each_element_with_text:: Calls the given block with each child element +# that meets given criteria, +# which can include text. +# #get_elements:: Returns an array of element children that match a given xpath. +# +# === Methods for \Text Children +# +# #add_text:: Adds a text node to the element. +# #get_text:: Returns a text node that meets specified criteria. +# #text:: Returns the text string from the first node that meets specified criteria. +# #texts:: Returns an array of the text children of the element. +# #text=:: Adds, removes, or replaces the first text child of the element +# +# === Methods for Other Children +# +# #cdatas:: Returns an array of the cdata children of the element. +# #comments:: Returns an array of the comment children of the element. +# #instructions:: Returns an array of the instruction children of the element. +# +# === Methods for Namespaces +# +# #add_namespace:: Adds a namespace to the element. +# #delete_namespace:: Removes a namespace from the element. +# #namespace:: Returns the string namespace URI for the element. +# #namespaces:: Returns a hash of all defined namespaces in the element. +# #prefixes:: Returns an array of the string prefixes (names) +# of all defined namespaces in the element +# +# === Methods for Querying +# +# #document:: Returns the document, if any, that the element belongs to. +# #root:: Returns the most distant element (not document) ancestor of the element. +# #root_node:: Returns the most distant ancestor of the element. +# #xpath:: Returns the string xpath to the element +# relative to the most distant parent +# #has_attributes?:: Returns whether the element has attributes. +# #has_elements?:: Returns whether the element has elements. +# #has_text?:: Returns whether the element has text. +# #next_element:: Returns the next sibling that is an element. +# #previous_element:: Returns the previous sibling that is an element. +# #raw:: Returns whether raw mode is set for the element. +# #whitespace:: Returns whether whitespace is respected for the element. +# #ignore_whitespace_nodes:: Returns whether whitespace nodes +# are to be ignored for the element. +# #node_type:: Returns symbol :element. +# +# === One More Method +# +# #inspect:: Returns a string representation of the element. +# +# === Accessors +# +# #elements:: Returns the REXML::Elements object for the element. +# #attributes:: Returns the REXML::Attributes object for the element. +# #context:: Returns or sets the context hash for the element. +# +# source://rexml-3.2.5/lib/rexml/element.rb:279 +class REXML::Element < ::REXML::Parent + include ::REXML::XMLTokens + include ::REXML::Namespace + + # :call-seq: + # Element.new(name = 'UNDEFINED', parent = nil, context = nil) -> new_element + # Element.new(element, parent = nil, context = nil) -> new_element + # + # Returns a new \REXML::Element object. + # + # When no arguments are given, + # returns an element with name 'UNDEFINED': + # + # e = REXML::Element.new # => + # e.class # => REXML::Element + # e.name # => "UNDEFINED" + # + # When only argument +name+ is given, + # returns an element of the given name: + # + # REXML::Element.new('foo') # => + # + # When only argument +element+ is given, it must be an \REXML::Element object; + # returns a shallow copy of the given element: + # + # e0 = REXML::Element.new('foo') + # e1 = REXML::Element.new(e0) # => + # + # When argument +parent+ is also given, it must be an REXML::Parent object: + # + # e = REXML::Element.new('foo', REXML::Parent.new) + # e.parent # => #]> + # + # When argument +context+ is also given, it must be a hash + # representing the context for the element; + # see {Element Context}[../doc/rexml/context_rdoc.html]: + # + # e = REXML::Element.new('foo', nil, {raw: :all}) + # e.context # => {:raw=>:all} + # + # @return [Element] a new instance of Element + # + # source://rexml-3.2.5/lib/rexml/element.rb:327 + def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end + + # :call-seq: + # [index] -> object + # [attr_name] -> attr_value + # [attr_sym] -> attr_value + # + # With integer argument +index+ given, + # returns the child at offset +index+, or +nil+ if none: + # + # d = REXML::Document.new '>textmore' + # root = d.root + # (0..root.size).each do |index| + # node = root[index] + # p "#{index}: #{node} (#{node.class})" + # end + # + # Output: + # + # "0: (REXML::Element)" + # "1: text (REXML::Text)" + # "2: (REXML::Element)" + # "3: more (REXML::Text)" + # "4: (REXML::Element)" + # "5: (NilClass)" + # + # With string argument +attr_name+ given, + # returns the string value for the given attribute name if it exists, + # otherwise +nil+: + # + # d = REXML::Document.new('') + # root = d.root + # root['attr'] # => "value" + # root['nosuch'] # => nil + # + # With symbol argument +attr_sym+ given, + # returns [attr_sym.to_s]: + # + # root[:attr] # => "value" + # root[:nosuch] # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:1245 + def [](name_or_index); end + + # :call-seq: + # add_attribute(name, value) -> value + # add_attribute(attribute) -> attribute + # + # Adds an attribute to this element, overwriting any existing attribute + # by the same name. + # + # With string argument +name+ and object +value+ are given, + # adds the attribute created with that name and value: + # + # e = REXML::Element.new + # e.add_attribute('attr', 'value') # => "value" + # e['attr'] # => "value" + # e.add_attribute('attr', 'VALUE') # => "VALUE" + # e['attr'] # => "VALUE" + # + # With only attribute object +attribute+ given, + # adds the given attribute: + # + # a = REXML::Attribute.new('attr', 'value') + # e.add_attribute(a) # => attr='value' + # e['attr'] # => "value" + # a = REXML::Attribute.new('attr', 'VALUE') + # e.add_attribute(a) # => attr='VALUE' + # e['attr'] # => "VALUE" + # + # source://rexml-3.2.5/lib/rexml/element.rb:1349 + def add_attribute(key, value = T.unsafe(nil)); end + + # :call-seq: + # add_attributes(hash) -> hash + # add_attributes(array) + # + # Adds zero or more attributes to the element; + # returns the argument. + # + # If hash argument +hash+ is given, + # each key must be a string; + # adds each attribute created with the key/value pair: + # + # e = REXML::Element.new + # h = {'foo' => 'bar', 'baz' => 'bat'} + # e.add_attributes(h) + # + # If argument +array+ is given, + # each array member must be a 2-element array [name, value]; + # each name must be a string: + # + # e = REXML::Element.new + # a = [['foo' => 'bar'], ['baz' => 'bat']] + # e.add_attributes(a) + # + # source://rexml-3.2.5/lib/rexml/element.rb:1380 + def add_attributes(hash); end + + # :call-seq: + # add_element(name, attributes = nil) -> new_element + # add_element(element, attributes = nil) -> element + # + # Adds a child element, optionally setting attributes + # on the added element; returns the added element. + # + # With string argument +name+, creates a new element with that name + # and adds the new element as a child: + # + # e0 = REXML::Element.new('foo') + # e0.add_element('bar') + # e0[0] # => + # + # + # With argument +name+ and hash argument +attributes+, + # sets attributes on the new element: + # + # e0.add_element('baz', {'bat' => '0', 'bam' => '1'}) + # e0[1] # => + # + # With element argument +element+, adds that element as a child: + # + # e0 = REXML::Element.new('foo') + # e1 = REXML::Element.new('bar') + # e0.add_element(e1) + # e0[0] # => + # + # With argument +element+ and hash argument +attributes+, + # sets attributes on the added element: + # + # e0.add_element(e1, {'bat' => '0', 'bam' => '1'}) + # e0[1] # => + # + # source://rexml-3.2.5/lib/rexml/element.rb:731 + def add_element(element, attrs = T.unsafe(nil)); end + + # :call-seq: + # add_namespace(prefix, uri = nil) -> self + # + # Adds a namespace to the element; returns +self+. + # + # With the single argument +prefix+, + # adds a namespace using the given +prefix+ and the namespace URI: + # + # e = REXML::Element.new('foo') + # e.add_namespace('bar') + # e.namespaces # => {"xmlns"=>"bar"} + # + # With both arguments +prefix+ and +uri+ given, + # adds a namespace using both arguments: + # + # e.add_namespace('baz', 'bat') + # e.namespaces # => {"xmlns"=>"bar", "baz"=>"bat"} + # + # source://rexml-3.2.5/lib/rexml/element.rb:654 + def add_namespace(prefix, uri = T.unsafe(nil)); end + + # :call-seq: + # add_text(string) -> nil + # add_text(text_node) -> self + # + # Adds text to the element. + # + # When string argument +string+ is given, returns +nil+. + # + # If the element has no child text node, + # creates a \REXML::Text object using the string, + # honoring the current settings for whitespace and raw, + # then adds that node to the element: + # + # d = REXML::Document.new('') + # a = d.root + # a.add_text('foo') + # a.to_a # => [, "foo"] + # + # If the element has child text nodes, + # appends the string to the _last_ text node: + # + # d = REXML::Document.new('foobar') + # a = d.root + # a.add_text('baz') + # a.to_a # => ["foo", , "barbaz"] + # a.add_text('baz') + # a.to_a # => ["foo", , "barbazbaz"] + # + # When text node argument +text_node+ is given, + # appends the node as the last text node in the element; + # returns +self+: + # + # d = REXML::Document.new('foobar') + # a = d.root + # a.add_text(REXML::Text.new('baz')) + # a.to_a # => ["foo", , "bar", "baz"] + # a.add_text(REXML::Text.new('baz')) + # a.to_a # => ["foo", , "bar", "baz", "baz"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1146 + def add_text(text); end + + # :call-seq: + # attribute(name, namespace = nil) + # + # Returns the string value for the given attribute name. + # + # With only argument +name+ given, + # returns the value of the named attribute if it exists, otherwise +nil+: + # + # xml_string = <<-EOT + # + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # root = d.root + # a = root[1] # => + # a.attribute('attr') # => attr='value' + # a.attribute('nope') # => nil + # + # With arguments +name+ and +namespace+ given, + # returns the value of the named attribute if it exists, otherwise +nil+: + # + # xml_string = "" + # document = REXML::Document.new(xml_string) + # document.root.attribute("x") # => x='x' + # document.root.attribute("x", "a") # => a:x='a:x' + # + # source://rexml-3.2.5/lib/rexml/element.rb:1286 + def attribute(name, namespace = T.unsafe(nil)); end + + # Mechanisms for accessing attributes and child elements of this + # element. + # + # source://rexml-3.2.5/lib/rexml/element.rb:286 + def attributes; end + + # :call-seq: + # cdatas -> array_of_cdata_children + # + # Returns a frozen array of the REXML::CData children of the element: + # + # xml_string = <<-EOT + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # cds = d.root.cdatas # => ["foo", "bar"] + # cds.frozen? # => true + # cds.map {|cd| cd.class } # => [REXML::CData, REXML::CData] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1424 + def cdatas; end + + # :call-seq: + # clone -> new_element + # + # Returns a shallow copy of the element, containing the name and attributes, + # but not the parent or children: + # + # e = REXML::Element.new('foo') + # e.add_attributes({'bar' => 0, 'baz' => 1}) + # e.clone # => + # + # source://rexml-3.2.5/lib/rexml/element.rb:391 + def clone; end + + # :call-seq: + # comments -> array_of_comment_children + # + # Returns a frozen array of the REXML::Comment children of the element: + # + # xml_string = <<-EOT + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # cs = d.root.comments + # cs.frozen? # => true + # cs.map {|c| c.class } # => [REXML::Comment, REXML::Comment] + # cs.map {|c| c.to_s } # => ["foo", "bar"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1445 + def comments; end + + # The context holds information about the processing environment, such as + # whitespace handling. + # + # source://rexml-3.2.5/lib/rexml/element.rb:289 + def context; end + + # The context holds information about the processing environment, such as + # whitespace handling. + # + # source://rexml-3.2.5/lib/rexml/element.rb:289 + def context=(_arg0); end + + # :call-seq: + # delete_attribute(name) -> removed_attribute or nil + # + # Removes a named attribute if it exists; + # returns the removed attribute if found, otherwise +nil+: + # + # e = REXML::Element.new('foo') + # e.add_attribute('bar', 'baz') + # e.delete_attribute('bar') # => + # e.delete_attribute('bar') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:1399 + def delete_attribute(key); end + + # :call-seq: + # delete_element(index) -> removed_element or nil + # delete_element(element) -> removed_element or nil + # delete_element(xpath) -> removed_element or nil + # + # Deletes a child element. + # + # When 1-based integer argument +index+ is given, + # removes and returns the child element at that offset if it exists; + # indexing does not include text nodes; + # returns +nil+ if the element does not exist: + # + # d = REXML::Document.new 'text' + # a = d.root # => ... + # a.delete_element(1) # => + # a.delete_element(1) # => + # a.delete_element(1) # => nil + # + # When element argument +element+ is given, + # removes and returns that child element if it exists, + # otherwise returns +nil+: + # + # d = REXML::Document.new 'text' + # a = d.root # => ... + # c = a[2] # => + # a.delete_element(c) # => + # a.delete_element(c) # => nil + # + # When xpath argument +xpath+ is given, + # removes and returns the element at xpath if it exists, + # otherwise returns +nil+: + # + # d = REXML::Document.new 'text' + # a = d.root # => ... + # a.delete_element('//c') # => + # a.delete_element('//c') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:777 + def delete_element(element); end + + # :call-seq: + # delete_namespace(namespace = 'xmlns') -> self + # + # Removes a namespace from the element. + # + # With no argument, removes the default namespace: + # + # d = REXML::Document.new "" + # d.to_s # => "" + # d.root.delete_namespace # => + # d.to_s # => "" + # + # With argument +namespace+, removes the specified namespace: + # + # d.root.delete_namespace('foo') + # d.to_s # => "" + # + # Does nothing if no such namespace is found: + # + # d.root.delete_namespace('nosuch') + # d.to_s # => "" + # + # source://rexml-3.2.5/lib/rexml/element.rb:686 + def delete_namespace(namespace = T.unsafe(nil)); end + + # :call-seq: + # document -> document or nil + # + # If the element is part of a document, returns that document: + # + # d = REXML::Document.new('') + # top_element = d.first + # child = top_element.first + # top_element.document == d # => true + # child.document == d # => true + # + # If the element is not part of a document, returns +nil+: + # + # REXML::Element.new.document # => nil + # + # For a document, returns +self+: + # + # d.document == d # => true + # + # Related: #root, #root_node. + # + # source://rexml-3.2.5/lib/rexml/element.rb:478 + def document; end + + # :call-seq: + # each_element {|e| ... } + # + # Calls the given block with each child element: + # + # d = REXML::Document.new 'bbd' + # a = d.root + # a.each_element {|e| p e } + # + # Output: + # + # ... + # ... + # ... + # + # + # source://rexml-3.2.5/lib/rexml/element.rb:929 + def each_element(xpath = T.unsafe(nil), &block); end + + # :call-seq: + # each_element_with_attribute(attr_name, value = nil, max = 0, xpath = nil) {|e| ... } + # + # Calls the given block with each child element that meets given criteria. + # + # When only string argument +attr_name+ is given, + # calls the block with each child element that has that attribute: + # + # d = REXML::Document.new '' + # a = d.root + # a.each_element_with_attribute('id') {|e| p e } + # + # Output: + # + # + # + # + # + # With argument +attr_name+ and string argument +value+ given, + # calls the block with each child element that has that attribute + # with that value: + # + # a.each_element_with_attribute('id', '1') {|e| p e } + # + # Output: + # + # + # + # + # With arguments +attr_name+, +value+, and integer argument +max+ given, + # calls the block with at most +max+ child elements: + # + # a.each_element_with_attribute('id', '1', 1) {|e| p e } + # + # Output: + # + # + # + # With all arguments given, including +xpath+, + # calls the block with only those child elements + # that meet the first three criteria, + # and also match the given +xpath+: + # + # a.each_element_with_attribute('id', '1', 2, '//d') {|e| p e } + # + # Output: + # + # + # + # source://rexml-3.2.5/lib/rexml/element.rb:846 + def each_element_with_attribute(key, value = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end + + # :call-seq: + # each_element_with_text(text = nil, max = 0, xpath = nil) {|e| ... } + # + # Calls the given block with each child element that meets given criteria. + # + # With no arguments, calls the block with each child element that has text: + # + # d = REXML::Document.new 'bbd' + # a = d.root + # a.each_element_with_text {|e| p e } + # + # Output: + # + # ... + # ... + # ... + # + # With the single string argument +text+, + # calls the block with each element that has exactly that text: + # + # a.each_element_with_text('b') {|e| p e } + # + # Output: + # + # ... + # ... + # + # With argument +text+ and integer argument +max+, + # calls the block with at most +max+ elements: + # + # a.each_element_with_text('b', 1) {|e| p e } + # + # Output: + # + # ... + # + # With all arguments given, including +xpath+, + # calls the block with only those child elements + # that meet the first two criteria, + # and also match the given +xpath+: + # + # a.each_element_with_text('b', 2, '//c') {|e| p e } + # + # Output: + # + # ... + # + # source://rexml-3.2.5/lib/rexml/element.rb:903 + def each_element_with_text(text = T.unsafe(nil), max = T.unsafe(nil), name = T.unsafe(nil), &block); end + + # Mechanisms for accessing attributes and child elements of this + # element. + # + # source://rexml-3.2.5/lib/rexml/element.rb:286 + def elements; end + + # :call-seq: + # get_elements(xpath) + # + # Returns an array of the elements that match the given +xpath+: + # + # xml_string = <<-EOT + # + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # d.root.get_elements('//a') # => [ ... , ] + # + # source://rexml-3.2.5/lib/rexml/element.rb:948 + def get_elements(xpath); end + + # :call-seq: + # get_text(xpath = nil) -> text_node or nil + # + # Returns the first text node child in a specified element, if it exists, + # +nil+ otherwise. + # + # With no argument, returns the first text node from +self+: + # + # d = REXML::Document.new "

some text this is bold! more text

" + # d.root.get_text.class # => REXML::Text + # d.root.get_text # => "some text " + # + # With argument +xpath+, returns the first text node from the element + # that matches +xpath+: + # + # d.root.get_text(1) # => "this is bold!" + # + # source://rexml-3.2.5/lib/rexml/element.rb:1052 + def get_text(path = T.unsafe(nil)); end + + # :call-seq: + # has_attributes? -> true or false + # + # Returns +true+ if the element has attributes, +false+ otherwise: + # + # d = REXML::Document.new('') + # a, b = *d.root + # a.has_attributes? # => true + # b.has_attributes? # => false + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1319 + def has_attributes?; end + + # :call-seq: + # has_elements? + # + # Returns +true+ if the element has one or more element children, + # +false+ otherwise: + # + # d = REXML::Document.new 'text' + # a = d.root # => ... + # a.has_elements? # => true + # b = a[0] # => + # b.has_elements? # => false + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/element.rb:793 + def has_elements?; end + + # :call-seq: + # has_text? -> true or false + # + # Returns +true if the element has one or more text noded, + # +false+ otherwise: + # + # d = REXML::Document.new 'text' + # a = d.root + # a.has_text? # => true + # b = a[0] + # b.has_text? # => false + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1001 + def has_text?; end + + # :call-seq: + # ignore_whitespace_nodes + # + # Returns +true+ if whitespace nodes are ignored for the element. + # + # See {Element Context}[../doc/rexml/context_rdoc.html]. + # + # source://rexml-3.2.5/lib/rexml/element.rb:516 + def ignore_whitespace_nodes; end + + # :call-seq: + # inspect -> string + # + # Returns a string representation of the element. + # + # For an element with no attributes and no children, shows the element name: + # + # REXML::Element.new.inspect # => "" + # + # Shows attributes, if any: + # + # e = REXML::Element.new('foo') + # e.add_attributes({'bar' => 0, 'baz' => 1}) + # e.inspect # => "" + # + # Shows an ellipsis (...), if there are child elements: + # + # e.add_element(REXML::Element.new('bar')) + # e.add_element(REXML::Element.new('baz')) + # e.inspect # => " ... " + # + # source://rexml-3.2.5/lib/rexml/element.rb:366 + def inspect; end + + # :call-seq: + # instructions -> array_of_instruction_children + # + # Returns a frozen array of the REXML::Instruction children of the element: + # + # xml_string = <<-EOT + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # is = d.root.instructions + # is.frozen? # => true + # is.map {|i| i.class } # => [REXML::Instruction, REXML::Instruction] + # is.map {|i| i.to_s } # => ["", ""] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1466 + def instructions; end + + # :call-seq: + # namespace(prefix = nil) -> string_uri or nil + # + # Returns the string namespace URI for the element, + # possibly deriving from one of its ancestors. + # + # xml_string = <<-EOT + # + # + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # b = d.elements['//b'] + # b.namespace # => "1" + # b.namespace('y') # => "2" + # b.namespace('nosuch') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:621 + def namespace(prefix = T.unsafe(nil)); end + + # :call-seq: + # namespaces -> array_of_namespace_names + # + # Returns a hash of all defined namespaces + # in the element and its ancestors: + # + # xml_string = <<-EOT + # + # + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string) + # d.elements['//a'].namespaces # => {"x"=>"1", "y"=>"2"} + # d.elements['//b'].namespaces # => {"x"=>"1", "y"=>"2"} + # d.elements['//c'].namespaces # => {"x"=>"1", "y"=>"2", "z"=>"3"} + # + # source://rexml-3.2.5/lib/rexml/element.rb:594 + def namespaces; end + + # :call-seq: + # next_element + # + # Returns the next sibling that is an element if it exists, + # +niL+ otherwise: + # + # d = REXML::Document.new 'text' + # d.root.elements['b'].next_element #-> + # d.root.elements['c'].next_element #-> nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:962 + def next_element; end + + # :call-seq: + # node_type -> :element + # + # Returns symbol :element: + # + # d = REXML::Document.new('') + # a = d.root # => + # a.node_type # => :element + # + # source://rexml-3.2.5/lib/rexml/element.rb:1167 + def node_type; end + + # :call-seq: + # prefixes -> array_of_namespace_prefixes + # + # Returns an array of the string prefixes (names) of all defined namespaces + # in the element and its ancestors: + # + # xml_string = <<-EOT + # + # + # + # + # + # + # EOT + # d = REXML::Document.new(xml_string, {compress_whitespace: :all}) + # d.elements['//a'].prefixes # => ["x", "y"] + # d.elements['//b'].prefixes # => ["x", "y"] + # d.elements['//c'].prefixes # => ["x", "y", "z"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:568 + def prefixes; end + + # :call-seq: + # previous_element + # + # Returns the previous sibling that is an element if it exists, + # +niL+ otherwise: + # + # d = REXML::Document.new 'text' + # d.root.elements['c'].previous_element #-> + # d.root.elements['b'].previous_element #-> nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:978 + def previous_element; end + + # :call-seq: + # raw + # + # Returns +true+ if raw mode is set for the element. + # + # See {Element Context}[../doc/rexml/context_rdoc.html]. + # + # The evaluation is tested against +expanded_name+, and so is namespace + # sensitive. + # + # source://rexml-3.2.5/lib/rexml/element.rb:536 + def raw; end + + # :call-seq: + # root -> element + # + # Returns the most distant _element_ (not document) ancestor of the element: + # + # d = REXML::Document.new('') + # top_element = d.first + # child = top_element.first + # top_element.root == top_element # => true + # child.root == top_element # => true + # + # For a document, returns the topmost element: + # + # d.root == top_element # => true + # + # Related: #root_node, #document. + # + # source://rexml-3.2.5/lib/rexml/element.rb:451 + def root; end + + # :call-seq: + # root_node -> document or element + # + # Returns the most distant ancestor of +self+. + # + # When the element is part of a document, + # returns the root node of the document. + # Note that the root node is different from the document element; + # in this example +a+ is document element and the root node is its parent: + # + # d = REXML::Document.new('') + # top_element = d.first # => ... + # child = top_element.first # => ... + # d.root_node == d # => true + # top_element.root_node == d # => true + # child.root_node == d # => true + # + # When the element is not part of a document, but does have ancestor elements, + # returns the most distant ancestor element: + # + # e0 = REXML::Element.new('foo') + # e1 = REXML::Element.new('bar') + # e1.parent = e0 + # e2 = REXML::Element.new('baz') + # e2.parent = e1 + # e2.root_node == e0 # => true + # + # When the element has no ancestor elements, + # returns +self+: + # + # e = REXML::Element.new('foo') + # e.root_node == e # => true + # + # Related: #root, #document. + # + # source://rexml-3.2.5/lib/rexml/element.rb:430 + def root_node; end + + # :call-seq: + # text(xpath = nil) -> text_string or nil + # + # Returns the text string from the first text node child + # in a specified element, if it exists, # +nil+ otherwise. + # + # With no argument, returns the text from the first text node in +self+: + # + # d = REXML::Document.new "

some text this is bold! more text

" + # d.root.text.class # => String + # d.root.text # => "some text " + # + # With argument +xpath+, returns text from the the first text node + # in the element that matches +xpath+: + # + # d.root.text(1) # => "this is bold!" + # + # Note that an element may have multiple text nodes, + # possibly separated by other non-text children, as above. + # Even so, the returned value is the string text from the first such node. + # + # Note also that the text note is retrieved by method get_text, + # and so is always normalized text. + # + # source://rexml-3.2.5/lib/rexml/element.rb:1029 + def text(path = T.unsafe(nil)); end + + # :call-seq: + # text = string -> string + # text = nil -> nil + # + # Adds, replaces, or removes the first text node child in the element. + # + # With string argument +string+, + # creates a new \REXML::Text node containing that string, + # honoring the current settings for whitespace and row, + # then places the node as the first text child in the element; + # returns +string+. + # + # If the element has no text child, the text node is added: + # + # d = REXML::Document.new '' + # d.root.text = 'foo' #-> 'foo' + # + # If the element has a text child, it is replaced: + # + # d.root.text = 'bar' #-> 'bar' + # + # With argument +nil+, removes the first text child: + # + # d.root.text = nil #-> '' + # + # source://rexml-3.2.5/lib/rexml/element.rb:1088 + def text=(text); end + + # :call-seq: + # texts -> array_of_text_children + # + # Returns a frozen array of the REXML::Text children of the element: + # + # xml_string = 'textmore' + # d = REXML::Document.new(xml_string) + # ts = d.root.texts + # ts.frozen? # => true + # ts.map {|t| t.class } # => [REXML::Text, REXML::Text] + # ts.map {|t| t.to_s } # => ["text", "more"] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1482 + def texts; end + + # :call-seq: + # whitespace + # + # Returns +true+ if whitespace is respected for this element, + # +false+ otherwise. + # + # See {Element Context}[../doc/rexml/context_rdoc.html]. + # + # The evaluation is tested against the element's +expanded_name+, + # and so is namespace-sensitive. + # + # source://rexml-3.2.5/lib/rexml/element.rb:493 + def whitespace; end + + # == DEPRECATED + # See REXML::Formatters + # + # Writes out this element, and recursively, all children. + # output:: + # output an object which supports '<< string'; this is where the + # document will be written. + # indent:: + # An integer. If -1, no indenting will be used; otherwise, the + # indentation will be this number of spaces, and children will be + # indented an additional amount. Defaults to -1 + # transitive:: + # If transitive is true and indent is >= 0, then the output will be + # pretty-printed in such a way that the added whitespace does not affect + # the parse tree of the document + # ie_hack:: + # This hack inserts a space before the /> on empty tags to address + # a limitation of Internet Explorer. Defaults to false + # + # out = '' + # doc.write( out ) #-> doc is written to the string 'out' + # doc.write( $stdout ) #-> doc written to the console + # + # source://rexml-3.2.5/lib/rexml/element.rb:1508 + def write(output = T.unsafe(nil), indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end + + # :call-seq: + # xpath -> string_xpath + # + # Returns the string xpath to the element + # relative to the most distant parent: + # + # d = REXML::Document.new('') + # a = d.root # => ... + # b = a[0] # => ... + # c = b[0] # => + # d.xpath # => "" + # a.xpath # => "/a" + # b.xpath # => "/a/b" + # c.xpath # => "/a/b/c" + # + # If there is no parent, returns the expanded name of the element: + # + # e = REXML::Element.new('foo') + # e.xpath # => "foo" + # + # source://rexml-3.2.5/lib/rexml/element.rb:1191 + def xpath; end + + private + + # source://rexml-3.2.5/lib/rexml/element.rb:1525 + def __to_xpath_helper(node); end + + # A private helper method + # + # source://rexml-3.2.5/lib/rexml/element.rb:1540 + def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end +end + +# source://rexml-3.2.5/lib/rexml/doctype.rb:261 +class REXML::ElementDecl < ::REXML::Declaration + # @return [ElementDecl] a new instance of ElementDecl + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:262 + def initialize(src); end +end + +# A class which provides filtering of children for Elements, and +# XPath search support. You are expected to only encounter this class as +# the element.elements object. Therefore, you are +# _not_ expected to instantiate this yourself. +# +# xml_string = <<-EOT +# +# +# +# Everyday Italian +# Giada De Laurentiis +# 2005 +# 30.00 +# +# +# Harry Potter +# J K. Rowling +# 2005 +# 29.99 +# +# +# XQuery Kick Start +# James McGovern +# Per Bothner +# Kurt Cagle +# James Linn +# Vaidyanathan Nagarajan +# 2003 +# 49.99 +# +# +# Learning XML +# Erik T. Ray +# 2003 +# 39.95 +# +# +# EOT +# d = REXML::Document.new(xml_string) +# elements = d.root.elements +# elements # => # ... > +# +# source://rexml-3.2.5/lib/rexml/element.rb:1595 +class REXML::Elements + include ::Enumerable + + # :call-seq: + # new(parent) -> new_elements_object + # + # Returns a new \Elements object with the given +parent+. + # Does _not_ assign parent.elements = self: + # + # d = REXML::Document.new(xml_string) + # eles = REXML::Elements.new(d.root) + # eles # => # ... > + # eles == d.root.elements # => false + # + # @return [Elements] a new instance of Elements + # + # source://rexml-3.2.5/lib/rexml/element.rb:1608 + def initialize(parent); end + + # :call-seq: + # add -> new_element + # add(name) -> new_element + # add(element) -> element + # + # Adds an element; returns the element added. + # + # With no argument, creates and adds a new element. + # The new element has: + # + # - No name. + # - \Parent from the \Elements object. + # - Context from the that parent. + # + # Example: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # parent = elements.parent # => ... + # parent.context = {raw: :all} + # elements.size # => 4 + # new_element = elements.add # => + # elements.size # => 5 + # new_element.name # => nil + # new_element.parent # => ... + # new_element.context # => {:raw=>:all} + # + # With string argument +name+, creates and adds a new element. + # The new element has: + # + # - Name +name+. + # - \Parent from the \Elements object. + # - Context from the that parent. + # + # Example: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # parent = elements.parent # => ... + # parent.context = {raw: :all} + # elements.size # => 4 + # new_element = elements.add('foo') # => + # elements.size # => 5 + # new_element.name # => "foo" + # new_element.parent # => ... + # new_element.context # => {:raw=>:all} + # + # With argument +element+, + # creates and adds a clone of the given +element+. + # The new element has name, parent, and context from the given +element+. + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.size # => 4 + # e0 = REXML::Element.new('foo') + # e1 = REXML::Element.new('bar', e0, {raw: :all}) + # element = elements.add(e1) # => + # elements.size # => 5 + # element.name # => "bar" + # element.parent # => ... + # element.context # => {:raw=>:all} + # + # source://rexml-3.2.5/lib/rexml/element.rb:1925 + def <<(element = T.unsafe(nil)); end + + # :call-seq: + # elements[index] -> element or nil + # elements[xpath] -> element or nil + # elements[n, name] -> element or nil + # + # Returns the first \Element object selected by the arguments, + # if any found, or +nil+ if none found. + # + # Notes: + # - The +index+ is 1-based, not 0-based, so that: + # - The first element has index 1 + # - The _nth_ element has index +n+. + # - The selection ignores non-\Element nodes. + # + # When the single argument +index+ is given, + # returns the element given by the index, if any; otherwise, +nil+: + # + # d = REXML::Document.new(xml_string) + # eles = d.root.elements + # eles # => # ... > + # eles[1] # => ... + # eles.size # => 4 + # eles[4] # => ... + # eles[5] # => nil + # + # The node at this index is not an \Element, and so is not returned: + # + # eles = d.root.first.first # => ... </> + # eles.to_a # => ["Everyday Italian"] + # eles[1] # => nil + # + # When the single argument +xpath+ is given, + # returns the first element found via that +xpath+, if any; otherwise, +nil+: + # + # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>> + # eles['/bookstore'] # => <bookstore> ... </> + # eles['//book'] # => <book category='cooking'> ... </> + # eles['//book [@category="children"]'] # => <book category='children'> ... </> + # eles['/nosuch'] # => nil + # eles['//nosuch'] # => nil + # eles['//book [@category="nosuch"]'] # => nil + # eles['.'] # => <bookstore> ... </> + # eles['..'].class # => REXML::Document + # + # With arguments +n+ and +name+ given, + # returns the _nth_ found element that has the given +name+, + # or +nil+ if there is no such _nth_ element: + # + # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>> + # eles[1, 'book'] # => <book category='cooking'> ... </> + # eles[4, 'book'] # => <book category='web' cover='paperback'> ... </> + # eles[5, 'book'] # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:1680 + def [](index, name = T.unsafe(nil)); end + + # :call-seq: + # elements[] = index, replacement_element -> replacement_element or nil + # + # Replaces or adds an element. + # + # When <tt>eles[index]</tt> exists, replaces it with +replacement_element+ + # and returns +replacement_element+: + # + # d = REXML::Document.new(xml_string) + # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>> + # eles[1] # => <book category='cooking'> ... </> + # eles[1] = REXML::Element.new('foo') + # eles[1] # => <foo/> + # + # Does nothing (or raises an exception) + # if +replacement_element+ is not an \Element: + # eles[2] # => <book category='web' cover='paperback'> ... </> + # eles[2] = REXML::Text.new('bar') + # eles[2] # => <book category='web' cover='paperback'> ... </> + # + # When <tt>eles[index]</tt> does not exist, + # adds +replacement_element+ to the element and returns + # + # d = REXML::Document.new(xml_string) + # eles = d.root.elements # => #<REXML::Elements @element=<bookstore> ... </>> + # eles.size # => 4 + # eles[50] = REXML::Element.new('foo') # => <foo/> + # eles.size # => 5 + # eles[5] # => <foo/> + # + # Does nothing (or raises an exception) + # if +replacement_element+ is not an \Element: + # + # eles[50] = REXML::Text.new('bar') # => "bar" + # eles.size # => 5 + # + # source://rexml-3.2.5/lib/rexml/element.rb:1735 + def []=(index, element); end + + # :call-seq: + # add -> new_element + # add(name) -> new_element + # add(element) -> element + # + # Adds an element; returns the element added. + # + # With no argument, creates and adds a new element. + # The new element has: + # + # - No name. + # - \Parent from the \Elements object. + # - Context from the that parent. + # + # Example: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # parent = elements.parent # => <bookstore> ... </> + # parent.context = {raw: :all} + # elements.size # => 4 + # new_element = elements.add # => </> + # elements.size # => 5 + # new_element.name # => nil + # new_element.parent # => <bookstore> ... </> + # new_element.context # => {:raw=>:all} + # + # With string argument +name+, creates and adds a new element. + # The new element has: + # + # - Name +name+. + # - \Parent from the \Elements object. + # - Context from the that parent. + # + # Example: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # parent = elements.parent # => <bookstore> ... </> + # parent.context = {raw: :all} + # elements.size # => 4 + # new_element = elements.add('foo') # => <foo/> + # elements.size # => 5 + # new_element.name # => "foo" + # new_element.parent # => <bookstore> ... </> + # new_element.context # => {:raw=>:all} + # + # With argument +element+, + # creates and adds a clone of the given +element+. + # The new element has name, parent, and context from the given +element+. + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.size # => 4 + # e0 = REXML::Element.new('foo') + # e1 = REXML::Element.new('bar', e0, {raw: :all}) + # element = elements.add(e1) # => <bar/> + # elements.size # => 5 + # element.name # => "bar" + # element.parent # => <bookstore> ... </> + # element.context # => {:raw=>:all} + # + # source://rexml-3.2.5/lib/rexml/element.rb:1925 + def add(element = T.unsafe(nil)); end + + # :call-seq: + # collect(xpath = nil) {|element| ... } -> array + # + # Iterates over the elements; returns the array of block return values. + # + # With no argument, iterates over all elements: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.collect {|element| element.size } # => [9, 9, 17, 9] + # + # With argument +xpath+, iterates over elements that match + # the given +xpath+: + # + # xpath = '//book [@category="web"]' + # elements.collect(xpath) {|element| element.size } # => [17, 9] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1988 + def collect(xpath = T.unsafe(nil)); end + + # :call-seq: + # delete(index) -> removed_element or nil + # delete(element) -> removed_element or nil + # delete(xpath) -> removed_element or nil + # + # Removes an element; returns the removed element, or +nil+ if none removed. + # + # With integer argument +index+ given, + # removes the child element at that offset: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.size # => 4 + # elements[2] # => <book category='children'> ... </> + # elements.delete(2) # => <book category='children'> ... </> + # elements.size # => 3 + # elements[2] # => <book category='web'> ... </> + # elements.delete(50) # => nil + # + # With element argument +element+ given, + # removes that child element: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # ele_1, ele_2, ele_3, ele_4 = *elements + # elements.size # => 4 + # elements[2] # => <book category='children'> ... </> + # elements.delete(ele_2) # => <book category='children'> ... </> + # elements.size # => 3 + # elements[2] # => <book category='web'> ... </> + # elements.delete(ele_2) # => nil + # + # With string argument +xpath+ given, + # removes the first element found via that xpath: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.delete('//book') # => <book category='cooking'> ... </> + # elements.delete('//book [@category="children"]') # => <book category='children'> ... </> + # elements.delete('//nosuch') # => nil + # + # source://rexml-3.2.5/lib/rexml/element.rb:1825 + def delete(element); end + + # :call-seq: + # delete_all(xpath) + # + # Removes all elements found via the given +xpath+; + # returns the array of removed elements, if any, else +nil+. + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.size # => 4 + # deleted_elements = elements.delete_all('//book [@category="web"]') + # deleted_elements.size # => 2 + # elements.size # => 2 + # deleted_elements = elements.delete_all('//book') + # deleted_elements.size # => 2 + # elements.size # => 0 + # elements.delete_all('//book') # => [] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1851 + def delete_all(xpath); end + + # :call-seq: + # each(xpath = nil) {|element| ... } -> self + # + # Iterates over the elements. + # + # With no argument, calls the block with each element: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.each {|element| p element } + # + # Output: + # + # <book category='cooking'> ... </> + # <book category='children'> ... </> + # <book category='web'> ... </> + # <book category='web' cover='paperback'> ... </> + # + # With argument +xpath+, calls the block with each element + # that matches the given +xpath+: + # + # elements.each('//book [@category="web"]') {|element| p element } + # + # Output: + # + # <book category='web'> ... </> + # <book category='web' cover='paperback'> ... </> + # + # source://rexml-3.2.5/lib/rexml/element.rb:1967 + def each(xpath = T.unsafe(nil)); end + + # :call-seq: + # empty? -> true or false + # + # Returns +true+ if there are no children, +false+ otherwise. + # + # d = REXML::Document.new('') + # d.elements.empty? # => true + # d = REXML::Document.new(xml_string) + # d.elements.empty? # => false + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/element.rb:1755 + def empty?; end + + # :call-seq: + # index(element) + # + # Returns the 1-based index of the given +element+, if found; + # otherwise, returns -1: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # ele_1, ele_2, ele_3, ele_4 = *elements + # elements.index(ele_4) # => 4 + # elements.delete(ele_3) + # elements.index(ele_4) # => 3 + # elements.index(ele_3) # => -1 + # + # source://rexml-3.2.5/lib/rexml/element.rb:1773 + def index(element); end + + # :call-seq: + # inject(xpath = nil, initial = nil) -> object + # + # Calls the block with elements; returns the last block return value. + # + # With no argument, iterates over the elements, calling the block + # <tt>elements.size - 1</tt> times. + # + # - The first call passes the first and second elements. + # - The second call passes the first block return value and the third element. + # - The third call passes the second block return value and the fourth element. + # - And so on. + # + # In this example, the block returns the passed element, + # which is then the object argument to the next call: + # + # d = REXML::Document.new(xml_string) + # elements = d.root.elements + # elements.inject do |object, element| + # p [elements.index(object), elements.index(element)] + # element + # end + # + # Output: + # + # [1, 2] + # [2, 3] + # [3, 4] + # + # With the single argument +xpath+, calls the block only with + # elements matching that xpath: + # + # elements.inject('//book [@category="web"]') do |object, element| + # p [elements.index(object), elements.index(element)] + # element + # end + # + # Output: + # + # [3, 4] + # + # With argument +xpath+ given as +nil+ + # and argument +initial+ also given, + # calls the block once for each element. + # + # - The first call passes the +initial+ and the first element. + # - The second call passes the first block return value and the second element. + # - The third call passes the second block return value and the third element. + # - And so on. + # + # In this example, the first object index is <tt>-1</tt> + # + # elements.inject(nil, 'Initial') do |object, element| + # p [elements.index(object), elements.index(element)] + # element + # end + # + # Output: + # + # [-1, 1] + # [1, 2] + # [2, 3] + # [3, 4] + # + # In this form the passed object can be used as an accumulator: + # + # elements.inject(nil, 0) do |total, element| + # total += element.size + # end # => 44 + # + # With both arguments +xpath+ and +initial+ are given, + # calls the block only with elements matching that xpath: + # + # elements.inject('//book [@category="web"]', 0) do |total, element| + # total += element.size + # end # => 26 + # + # source://rexml-3.2.5/lib/rexml/element.rb:2073 + def inject(xpath = T.unsafe(nil), initial = T.unsafe(nil)); end + + # :call-seq: + # parent + # + # Returns the parent element cited in creating the \Elements object. + # This element is also the default starting point for searching + # in the \Elements object. + # + # d = REXML::Document.new(xml_string) + # elements = REXML::Elements.new(d.root) + # elements.parent == d.root # => true + # + # source://rexml-3.2.5/lib/rexml/element.rb:1623 + def parent; end + + # :call-seq: + # size -> integer + # + # Returns the count of \Element children: + # + # d = REXML::Document.new '<a>sean<b/>elliott<b/>russell<b/></a>' + # d.root.elements.size # => 3 # Three elements. + # d.root.size # => 6 # Three elements plus three text nodes.. + # + # source://rexml-3.2.5/lib/rexml/element.rb:2097 + def size; end + + # :call-seq: + # to_a(xpath = nil) -> array_of_elements + # + # Returns an array of element children (not including non-element children). + # + # With no argument, returns an array of all element children: + # + # d = REXML::Document.new '<a>sean<b/>elliott<c/></a>' + # elements = d.root.elements + # elements.to_a # => [<b/>, <c/>] # Omits non-element children. + # children = d.root.children + # children # => ["sean", <b/>, "elliott", <c/>] # Includes non-element children. + # + # With argument +xpath+, returns an array of element children + # that match the xpath: + # + # elements.to_a('//c') # => [<c/>] + # + # source://rexml-3.2.5/lib/rexml/element.rb:2121 + def to_a(xpath = T.unsafe(nil)); end + + private + + # Private helper class. Removes quotes from quoted strings + # + # source://rexml-3.2.5/lib/rexml/element.rb:2129 + def literalize(name); end +end + +# source://rexml-3.2.5/lib/rexml/encoding.rb:4 +module REXML::Encoding + # source://rexml-3.2.5/lib/rexml/encoding.rb:29 + def decode(string); end + + # source://rexml-3.2.5/lib/rexml/encoding.rb:25 + def encode(string); end + + # ID ---> Encoding name + # + # source://rexml-3.2.5/lib/rexml/encoding.rb:6 + def encoding; end + + # source://rexml-3.2.5/lib/rexml/encoding.rb:7 + def encoding=(encoding); end + + private + + # source://rexml-3.2.5/lib/rexml/encoding.rb:34 + def find_encoding(name); end +end + +# source://rexml-3.2.5/lib/rexml/entity.rb:7 +class REXML::Entity < ::REXML::Child + include ::REXML::XMLTokens + + # Create a new entity. Simple entities can be constructed by passing a + # name, value to the constructor; this creates a generic, plain entity + # reference. For anything more complicated, you have to pass a Source to + # the constructor with the entity definition, or use the accessor methods. + # +WARNING+: There is no validation of entity state except when the entity + # is read from a stream. If you start poking around with the accessors, + # you can easily create a non-conformant Entity. + # + # e = Entity.new( 'amp', '&' ) + # + # @return [Entity] a new instance of Entity + # + # source://rexml-3.2.5/lib/rexml/entity.rb:33 + def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end + + # Returns the value of attribute external. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:22 + def external; end + + # Returns the value of attribute name. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:22 + def name; end + + # Returns the value of attribute ndata. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:22 + def ndata; end + + # Returns the value of this entity unprocessed -- raw. This is the + # normalized value; that is, with all %ent; and &ent; entities intact + # + # source://rexml-3.2.5/lib/rexml/entity.rb:85 + def normalized; end + + # Returns the value of attribute pubid. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:22 + def pubid; end + + # Returns the value of attribute ref. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:22 + def ref; end + + # Returns this entity as a string. See write(). + # + # source://rexml-3.2.5/lib/rexml/entity.rb:119 + def to_s; end + + # Evaluates to the unnormalized value of this entity; that is, replacing + # all entities -- both %ent; and &ent; entities. This differs from + # +value()+ in that +value+ only replaces %ent; entities. + # + # source://rexml-3.2.5/lib/rexml/entity.rb:73 + def unnormalized; end + + # Returns the value of this entity. At the moment, only internal entities + # are processed. If the value contains internal references (IE, + # %blah;), those are replaced with their values. IE, if the doctype + # contains: + # <!ENTITY % foo "bar"> + # <!ENTITY yada "nanoo %foo; nanoo> + # then: + # doctype.entity('yada').value #-> "nanoo bar nanoo" + # + # source://rexml-3.2.5/lib/rexml/entity.rb:134 + def value; end + + # Write out a fully formed, correct entity definition (assuming the Entity + # object itself is valid.) + # + # out:: + # An object implementing <TT><<</TT> to which the entity will be + # output + # indent:: + # *DEPRECATED* and ignored + # + # source://rexml-3.2.5/lib/rexml/entity.rb:97 + def write(out, indent = T.unsafe(nil)); end + + class << self + # Evaluates whether the given string matches an entity definition, + # returning true if so, and false otherwise. + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/entity.rb:66 + def matches?(string); end + end +end + +# source://rexml-3.2.5/lib/rexml/doctype.rb:267 +class REXML::ExternalEntity < ::REXML::Child + # @return [ExternalEntity] a new instance of ExternalEntity + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:268 + def initialize(src); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:272 + def to_s; end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:275 + def write(output, indent); end +end + +# source://rexml-3.2.5/lib/rexml/formatters/default.rb:5 +class REXML::Formatters::Default + # Prints out the XML document with no formatting -- except if ie_hack is + # set. + # + # ie_hack:: + # If set to true, then inserts whitespace before the close of an empty + # tag, so that IE's bad XML parser doesn't choke. + # + # @return [Default] a new instance of Default + # + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:12 + def initialize(ie_hack = T.unsafe(nil)); end + + # Writes the node to some output. + # + # node:: + # The node to write + # output:: + # A class implementing <TT><<</TT>. Pass in an Output object to + # change the output encoding. + # + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:23 + def write(node, output); end + + protected + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:98 + def write_cdata(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:92 + def write_comment(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:61 + def write_document(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:65 + def write_element(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:104 + def write_instruction(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/default.rb:88 + def write_text(node, output); end +end + +# Pretty-prints an XML document. This destroys whitespace in text nodes +# and will insert carriage returns and indentations. +# +# TODO: Add an option to print attributes on new lines +# +# source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:10 +class REXML::Formatters::Pretty < ::REXML::Formatters::Default + # Create a new pretty printer. + # + # output:: + # An object implementing '<<(String)', to which the output will be written. + # indentation:: + # An integer greater than 0. The indentation of each level will be + # this number of spaces. If this is < 1, the behavior of this object + # is undefined. Defaults to 2. + # ie_hack:: + # If true, the printer will insert whitespace before closing empty + # tags, thereby allowing Internet Explorer's XML parser to + # function. Defaults to false. + # + # @return [Pretty] a new instance of Pretty + # + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:30 + def initialize(indentation = T.unsafe(nil), ie_hack = T.unsafe(nil)); end + + # If compact is set to true, then the formatter will attempt to use as + # little space as possible + # + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:14 + def compact; end + + # If compact is set to true, then the formatter will attempt to use as + # little space as possible + # + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:14 + def compact=(_arg0); end + + # The width of a page. Used for formatting text + # + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:16 + def width; end + + # The width of a page. Used for formatting text + # + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:16 + def width=(_arg0); end + + protected + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:102 + def write_cdata(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:97 + def write_comment(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:107 + def write_document(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:39 + def write_element(node, output); end + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:88 + def write_text(node, output); end + + private + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:124 + def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/formatters/pretty.rb:129 + def wrap(string, width); end +end + +# A Source that wraps an IO. See the Source class for method +# documentation +# +# source://rexml-3.2.5/lib/rexml/source.rb:160 +class REXML::IOSource < ::REXML::Source + # block_size has been deprecated + # + # @return [IOSource] a new instance of IOSource + # + # source://rexml-3.2.5/lib/rexml/source.rb:163 + def initialize(arg, block_size = T.unsafe(nil), encoding = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/source.rb:215 + def consume(pattern); end + + # @return the current line in the source + # + # source://rexml-3.2.5/lib/rexml/source.rb:244 + def current_line; end + + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/source.rb:235 + def empty?; end + + # source://rexml-3.2.5/lib/rexml/source.rb:219 + def match(pattern, cons = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/source.rb:239 + def position; end + + # source://rexml-3.2.5/lib/rexml/source.rb:207 + def read; end + + # source://rexml-3.2.5/lib/rexml/source.rb:184 + def scan(pattern, cons = T.unsafe(nil)); end + + private + + # source://rexml-3.2.5/lib/rexml/source.rb:286 + def encoding_updated; end + + # source://rexml-3.2.5/lib/rexml/source.rb:266 + def readline; end +end + +# Represents an XML Instruction; IE, <? ... ?> +# TODO: Add parent arg (3rd arg) to constructor +# +# source://rexml-3.2.5/lib/rexml/instruction.rb:9 +class REXML::Instruction < ::REXML::Child + # Constructs a new Instruction + # the target of this instruction is set to this. If an Instruction, + # then the Instruction is shallowly cloned (target and content are + # copied). + # be a Parent if the target argument is a Source. Otherwise, this + # String is set as the content of this instruction. + # + # @param target can be one of a number of things. If String, then + # @param content Must be either a String, or a Parent. Can only + # @return [Instruction] a new instance of Instruction + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:25 + def initialize(target, content = T.unsafe(nil)); end + + # of the other matches the target and content of this object. + # + # @return true if other is an Instruction, and the content and target + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:65 + def ==(other); end + + # source://rexml-3.2.5/lib/rexml/instruction.rb:44 + def clone; end + + # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?> + # content is everything else. + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:15 + def content; end + + # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?> + # content is everything else. + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:15 + def content=(_arg0); end + + # source://rexml-3.2.5/lib/rexml/instruction.rb:75 + def inspect; end + + # source://rexml-3.2.5/lib/rexml/instruction.rb:71 + def node_type; end + + # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?> + # content is everything else. + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:15 + def target; end + + # target is the "name" of the Instruction; IE, the "tag" in <?tag ...?> + # content is everything else. + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:15 + def target=(_arg0); end + + # == DEPRECATED + # See the rexml/formatters package + # + # source://rexml-3.2.5/lib/rexml/instruction.rb:51 + def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end +end + +# source://rexml-3.2.5/lib/rexml/doctype.rb:280 +class REXML::NotationDecl < ::REXML::Child + # @return [NotationDecl] a new instance of NotationDecl + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:282 + def initialize(name, middle, pub, sys); end + + # This method retrieves the name of the notation. + # + # Method contributed by Henrik Martensson + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:307 + def name; end + + # Returns the value of attribute public. + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:281 + def public; end + + # Sets the attribute public + # + # @param value the value to set the attribute public to. + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:281 + def public=(_arg0); end + + # Returns the value of attribute system. + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:281 + def system; end + + # Sets the attribute system + # + # @param value the value to set the attribute system to. + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:281 + def system=(_arg0); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:290 + def to_s; end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:300 + def write(output, indent = T.unsafe(nil)); end +end + +# source://rexml-3.2.5/lib/rexml/output.rb:5 +class REXML::Output + include ::REXML::Encoding + + # @return [Output] a new instance of Output + # + # source://rexml-3.2.5/lib/rexml/output.rb:10 + def initialize(real_IO, encd = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/output.rb:22 + def <<(content); end + + # Returns the value of attribute encoding. + # + # source://rexml-3.2.5/lib/rexml/output.rb:8 + def encoding; end + + # source://rexml-3.2.5/lib/rexml/output.rb:26 + def to_s; end +end + +# A parent has children, and has methods for accessing them. The Parent +# class is never encountered except as the superclass for some other +# object. +# +# source://rexml-3.2.5/lib/rexml/parent.rb:8 +class REXML::Parent < ::REXML::Child + include ::Enumerable + + # Constructor + # + # @param parent if supplied, will be set as the parent of this object + # @return [Parent] a new instance of Parent + # + # source://rexml-3.2.5/lib/rexml/parent.rb:13 + def initialize(parent = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:18 + def <<(object); end + + # Fetches a child at a given index + # + # @param index the Integer index of the child to fetch + # + # source://rexml-3.2.5/lib/rexml/parent.rb:57 + def [](index); end + + # Set an index entry. See Array.[]= + # + # @param index the index of the element to set + # @param opt either the object to set, or an Integer length + # @param child if opt is an Integer, this is the child to set + # @return the parent (self) + # + # source://rexml-3.2.5/lib/rexml/parent.rb:70 + def []=(*args); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:18 + def add(object); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:115 + def children; end + + # Deeply clones this object. This creates a complete duplicate of this + # Parent, including all descendants. + # + # source://rexml-3.2.5/lib/rexml/parent.rb:148 + def deep_clone; end + + # source://rexml-3.2.5/lib/rexml/parent.rb:32 + def delete(object); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:47 + def delete_at(index); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:43 + def delete_if(&block); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:39 + def each(&block); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:39 + def each_child(&block); end + + # source://rexml-3.2.5/lib/rexml/parent.rb:51 + def each_index(&block); end + + # Fetches the index of a given child + # of this parent. + # + # @param child the child to get the index of + # @return the index of the child, or nil if the object is not a child + # + # source://rexml-3.2.5/lib/rexml/parent.rb:123 + def index(child); end + + # Inserts an child after another child + # child2 will be inserted after child1 in the child list of the parent. + # If an xpath, child2 will be inserted after the first child to match + # the xpath. + # + # @param child1 this is either an xpath or an Element. If an Element, + # @param child2 the child to insert + # @return the parent (self) + # + # source://rexml-3.2.5/lib/rexml/parent.rb:102 + def insert_after(child1, child2); end + + # Inserts an child before another child + # child2 will be inserted before child1 in the child list of the parent. + # If an xpath, child2 will be inserted before the first child to match + # the xpath. + # + # @param child1 this is either an xpath or an Element. If an Element, + # @param child2 the child to insert + # @return the parent (self) + # + # source://rexml-3.2.5/lib/rexml/parent.rb:82 + def insert_before(child1, child2); end + + # @return the number of children of this parent + # + # source://rexml-3.2.5/lib/rexml/parent.rb:130 + def length; end + + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/parent.rb:162 + def parent?; end + + # source://rexml-3.2.5/lib/rexml/parent.rb:18 + def push(object); end + + # Replaces one child with another, making sure the nodelist is correct + # Child) + # + # @param to_replace the child to replace (must be a Child) + # @param replacement the child to insert into the nodelist (must be a + # + # source://rexml-3.2.5/lib/rexml/parent.rb:140 + def replace_child(to_replace, replacement); end + + # @return the number of children of this parent + # + # source://rexml-3.2.5/lib/rexml/parent.rb:130 + def size; end + + # source://rexml-3.2.5/lib/rexml/parent.rb:115 + def to_a; end + + # source://rexml-3.2.5/lib/rexml/parent.rb:27 + def unshift(object); end +end + +# source://rexml-3.2.5/lib/rexml/parseexception.rb:3 +class REXML::ParseException < ::RuntimeError + # @return [ParseException] a new instance of ParseException + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:6 + def initialize(message, source = T.unsafe(nil), parser = T.unsafe(nil), exception = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/parseexception.rb:48 + def context; end + + # Returns the value of attribute continued_exception. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def continued_exception; end + + # Sets the attribute continued_exception + # + # @param value the value to set the attribute continued_exception to. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def continued_exception=(_arg0); end + + # source://rexml-3.2.5/lib/rexml/parseexception.rb:43 + def line; end + + # Returns the value of attribute parser. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def parser; end + + # Sets the attribute parser + # + # @param value the value to set the attribute parser to. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def parser=(_arg0); end + + # source://rexml-3.2.5/lib/rexml/parseexception.rb:38 + def position; end + + # Returns the value of attribute source. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def source; end + + # Sets the attribute source + # + # @param value the value to set the attribute source to. + # + # source://rexml-3.2.5/lib/rexml/parseexception.rb:4 + def source=(_arg0); end + + # source://rexml-3.2.5/lib/rexml/parseexception.rb:13 + def to_s; end +end + +# = Using the Pull Parser +# <em>This API is experimental, and subject to change.</em> +# parser = PullParser.new( "<a>text<b att='val'/>txet</a>" ) +# while parser.has_next? +# res = parser.next +# puts res[1]['att'] if res.start_tag? and res[0] == 'b' +# end +# See the PullEvent class for information on the content of the results. +# The data is identical to the arguments passed for the various events to +# the StreamListener API. +# +# Notice that: +# parser = PullParser.new( "<a>BAD DOCUMENT" ) +# while parser.has_next? +# res = parser.next +# raise res[1] if res.error? +# end +# +# Nat Price gave me some good ideas for the API. +# +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:29 +class REXML::Parsers::BaseParser + # @return [BaseParser] a new instance of BaseParser + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:115 + def initialize(source); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:120 + def add_listener(listener); end + + # Returns true if there are no more events + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:146 + def empty?; end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:438 + def entity(reference, entities); end + + # Returns true if there are more events. Synonymous with !empty? + # + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:151 + def has_next?; end + + # Escapes all possible entities + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:449 + def normalize(input, entities = T.unsafe(nil), entity_filter = T.unsafe(nil)); end + + # Peek at the +depth+ event in the stack. The first element on the stack + # is at depth 0. If +depth+ is -1, will parse to the end of the input + # stream and return the last event, which is always :end_document. + # Be aware that this causes the stream to be parsed up to the +depth+ + # event, so you can effectively pre-parse the entire document (pull the + # entire thing into memory) using this method. + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:167 + def peek(depth = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:136 + def position; end + + # Returns the next event. This is a +PullEvent+ object. + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:182 + def pull; end + + # Returns the value of attribute source. + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:124 + def source; end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:126 + def stream=(source); end + + # Unescapes all possible entities + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:465 + def unnormalize(string, entities = T.unsafe(nil), filter = T.unsafe(nil)); end + + # Push an event back on the head of the stream. This method + # has (theoretically) infinite depth. + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:157 + def unshift(token); end + + private + + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:495 + def need_source_encoding_update?(xml_declaration_encoding); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:589 + def parse_attributes(prefixes, curr_ns); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:514 + def parse_id(base_error_message, accept_external_id:, accept_public_id:); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:542 + def parse_id_invalid_details(accept_external_id:, accept_public_id:); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:501 + def parse_name(base_error_message); end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:580 + def process_instruction; end + + # source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:190 + def pull_event; end +end + +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:102 +REXML::Parsers::BaseParser::EXTERNAL_ID_PUBLIC = T.let(T.unsafe(nil), Regexp) + +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:103 +REXML::Parsers::BaseParser::EXTERNAL_ID_SYSTEM = T.let(T.unsafe(nil), Regexp) + +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:104 +REXML::Parsers::BaseParser::PUBLIC_ID = T.let(T.unsafe(nil), Regexp) + +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:38 +REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp) + +# source://rexml-3.2.5/lib/rexml/parsers/baseparser.rb:37 +REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String) + +# source://rexml-3.2.5/lib/rexml/parsers/streamparser.rb:6 +class REXML::Parsers::StreamParser + # @return [StreamParser] a new instance of StreamParser + # + # source://rexml-3.2.5/lib/rexml/parsers/streamparser.rb:7 + def initialize(source, listener); end + + # source://rexml-3.2.5/lib/rexml/parsers/streamparser.rb:13 + def add_listener(listener); end + + # source://rexml-3.2.5/lib/rexml/parsers/streamparser.rb:17 + def parse; end +end + +# source://rexml-3.2.5/lib/rexml/parsers/treeparser.rb:7 +class REXML::Parsers::TreeParser + # @return [TreeParser] a new instance of TreeParser + # + # source://rexml-3.2.5/lib/rexml/parsers/treeparser.rb:8 + def initialize(source, build_context = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/parsers/treeparser.rb:13 + def add_listener(listener); end + + # source://rexml-3.2.5/lib/rexml/parsers/treeparser.rb:17 + def parse; end +end + +# You don't want to use this class. Really. Use XPath, which is a wrapper +# for this class. Believe me. You don't want to poke around in here. +# There is strange, dark magic at work in this code. Beware. Go back! Go +# back while you still can! +# +# source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:11 +class REXML::Parsers::XPathParser + include ::REXML::XMLTokens + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:41 + def abbreviate(path); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:99 + def expand(path); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:15 + def namespaces=(namespaces); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:20 + def parse(path); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:35 + def predicate(path); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:138 + def predicate_to_string(path, &block); end + + private + + # | AdditiveExpr ('+' | '-') MultiplicativeExpr + # | MultiplicativeExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:455 + def AdditiveExpr(path, parsed); end + + # | AndExpr S 'and' S EqualityExpr + # | EqualityExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:388 + def AndExpr(path, parsed); end + + # | EqualityExpr ('=' | '!=') RelationalExpr + # | RelationalExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:407 + def EqualityExpr(path, parsed); end + + # | FilterExpr Predicate + # | PrimaryExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:558 + def FilterExpr(path, parsed); end + + # | FUNCTION_NAME '(' ( expr ( ',' expr )* )? ')' + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:613 + def FunctionCall(rest, parsed); end + + # LocationPath + # | RelativeLocationPath + # | '/' RelativeLocationPath? + # | '//' RelativeLocationPath + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:193 + def LocationPath(path, parsed); end + + # | MultiplicativeExpr ('*' | S ('div' | 'mod') S) UnaryExpr + # | UnaryExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:478 + def MultiplicativeExpr(path, parsed); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:293 + def NodeTest(path, parsed); end + + # | OrExpr S 'or' S AndExpr + # | AndExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:369 + def OrExpr(path, parsed); end + + # | LocationPath + # | FilterExpr ('/' | '//') RelativeLocationPath + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:540 + def PathExpr(path, parsed); end + + # Filters the supplied nodeset on the predicate(s) + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:345 + def Predicate(path, parsed); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:576 + def PrimaryExpr(path, parsed); end + + # | RelationalExpr ('<' | '>' | '<=' | '>=') AdditiveExpr + # | AdditiveExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:430 + def RelationalExpr(path, parsed); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:217 + def RelativeLocationPath(path, parsed); end + + # | '-' UnaryExpr + # | UnionExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:503 + def UnaryExpr(path, parsed); end + + # | UnionExpr '|' PathExpr + # | PathExpr + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:521 + def UnionExpr(path, parsed); end + + # get_group( '[foo]bar' ) -> ['bar', '[foo]'] + # + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:626 + def get_group(string); end + + # source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:644 + def parse_args(string); end +end + +# source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:289 +REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp) + +# Returns a 1-1 map of the nodeset +# The contents of the resulting array are either: +# true/false, if a positive match +# String, if a name match +# NodeTest +# | ('*' | NCNAME ':' '*' | QNAME) NameTest +# | '*' ':' NCNAME NameTest since XPath 2.0 +# | NODE_TYPE '(' ')' NodeType +# | PI '(' LITERAL ')' PI +# | '[' expr ']' Predicate +# +# source://rexml-3.2.5/lib/rexml/parsers/xpathparser.rb:288 +REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp) + +# source://rexml-3.2.5/lib/rexml/doctype.rb:10 +class REXML::ReferenceWriter + # @return [ReferenceWriter] a new instance of ReferenceWriter + # + # source://rexml-3.2.5/lib/rexml/doctype.rb:11 + def initialize(id_type, public_id_literal, system_literal, context = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/doctype.rb:25 + def write(output); end +end + +# A Source can be searched for patterns, and wraps buffers and other +# objects and provides consumption of text +# +# source://rexml-3.2.5/lib/rexml/source.rb:31 +class REXML::Source + include ::REXML::Encoding + + # Constructor + # value, overriding all encoding detection + # + # @param arg must be a String, and should be a valid XML document + # @param encoding if non-null, sets the encoding of the source to this + # @return [Source] a new instance of Source + # + # source://rexml-3.2.5/lib/rexml/source.rb:43 + def initialize(arg, encoding = T.unsafe(nil)); end + + # The current buffer (what we're going to read next) + # + # source://rexml-3.2.5/lib/rexml/source.rb:34 + def buffer; end + + # source://rexml-3.2.5/lib/rexml/source.rb:87 + def consume(pattern); end + + # @return the current line in the source + # + # source://rexml-3.2.5/lib/rexml/source.rb:117 + def current_line; end + + # @return [Boolean] true if the Source is exhausted + # + # source://rexml-3.2.5/lib/rexml/source.rb:108 + def empty?; end + + # Returns the value of attribute encoding. + # + # source://rexml-3.2.5/lib/rexml/source.rb:37 + def encoding; end + + # Inherited from Encoding + # Overridden to support optimized en/decoding + # + # source://rexml-3.2.5/lib/rexml/source.rb:56 + def encoding=(enc); end + + # The line number of the last consumed text + # + # source://rexml-3.2.5/lib/rexml/source.rb:36 + def line; end + + # source://rexml-3.2.5/lib/rexml/source.rb:101 + def match(pattern, cons = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/source.rb:91 + def match_to(char, pattern); end + + # source://rexml-3.2.5/lib/rexml/source.rb:95 + def match_to_consume(char, pattern); end + + # source://rexml-3.2.5/lib/rexml/source.rb:112 + def position; end + + # source://rexml-3.2.5/lib/rexml/source.rb:84 + def read; end + + # Scans the source for a given pattern. Note, that this is not your + # usual scan() method. For one thing, the pattern argument has some + # requirements; for another, the source can be consumed. You can easily + # confuse this method. Originally, the patterns were easier + # to construct and this method more robust, because this method + # generated search regexps on the fly; however, this was + # computationally expensive and slowed down the entire REXML package + # considerably, since this is by far the most commonly called method. + # /^\s*(#{your pattern, with no groups})(.*)/. The first group + # will be returned; the second group is used if the consume flag is + # set. + # everything after it in the Source. + # pattern is not found. + # + # @param pattern must be a Regexp, and must be in the form of + # @param consume if true, the pattern returned will be consumed, leaving + # @return the pattern, if found, or nil if the Source is empty or the + # + # source://rexml-3.2.5/lib/rexml/source.rb:77 + def scan(pattern, cons = T.unsafe(nil)); end + + private + + # source://rexml-3.2.5/lib/rexml/source.rb:125 + def detect_encoding; end + + # source://rexml-3.2.5/lib/rexml/source.rb:146 + def encoding_updated; end +end + +# Represents text nodes in an XML document +# +# source://rexml-3.2.5/lib/rexml/text.rb:11 +class REXML::Text < ::REXML::Child + include ::Comparable + + # Constructor + # +arg+ if a String, the content is set to the String. If a Text, + # the object is shallowly cloned. + # + # +respect_whitespace+ (boolean, false) if true, whitespace is + # respected + # + # +parent+ (nil) if this is a Parent object, the parent + # will be set to this. + # + # +raw+ (nil) This argument can be given three values. + # If true, then the value of used to construct this object is expected to + # contain no unescaped XML markup, and REXML will not change the text. If + # this value is false, the string may contain any characters, and REXML will + # escape any and all defined entities whose values are contained in the + # text. If this value is nil (the default), then the raw value of the + # parent will be used as the raw value for this node. If there is no raw + # value for the parent, and no value is supplied, the default is false. + # Use this field if you have entities defined for some text, and you don't + # want REXML to escape that text in output. + # Text.new( "<&", false, nil, false ) #-> "<&" + # Text.new( "<&", false, nil, false ) #-> "&lt;&amp;" + # Text.new( "<&", false, nil, true ) #-> Parse exception + # Text.new( "<&", false, nil, true ) #-> "<&" + # # Assume that the entity "s" is defined to be "sean" + # # and that the entity "r" is defined to be "russell" + # Text.new( "sean russell" ) #-> "&s; &r;" + # Text.new( "sean russell", false, nil, true ) #-> "sean russell" + # + # +entity_filter+ (nil) This can be an array of entities to match in the + # supplied text. This argument is only useful if +raw+ is set to false. + # Text.new( "sean russell", false, nil, false, ["s"] ) #-> "&s; russell" + # Text.new( "sean russell", false, nil, true, ["s"] ) #-> "sean russell" + # In the last example, the +entity_filter+ argument is ignored. + # + # +illegal+ INTERNAL USE ONLY + # + # @return [Text] a new instance of Text + # + # source://rexml-3.2.5/lib/rexml/text.rb:94 + def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end + + # Appends text to this text node. The text is appended in the +raw+ mode + # of this text node. + # + # +returns+ the text itself to enable method chain like + # 'text << "XXX" << "YYY"'. + # + # source://rexml-3.2.5/lib/rexml/text.rb:194 + def <<(to_append); end + + # +other+ a String or a Text + # +returns+ the result of (to_s <=> arg.to_s) + # + # source://rexml-3.2.5/lib/rexml/text.rb:203 + def <=>(other); end + + # source://rexml-3.2.5/lib/rexml/text.rb:184 + def clone; end + + # source://rexml-3.2.5/lib/rexml/text.rb:207 + def doctype; end + + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/text.rb:179 + def empty?; end + + # source://rexml-3.2.5/lib/rexml/text.rb:278 + def indent_text(string, level = T.unsafe(nil), style = T.unsafe(nil), indentfirstline = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/text.rb:233 + def inspect; end + + # source://rexml-3.2.5/lib/rexml/text.rb:175 + def node_type; end + + # source://rexml-3.2.5/lib/rexml/text.rb:125 + def parent=(parent); end + + # If +raw+ is true, then REXML leaves the value alone + # + # source://rexml-3.2.5/lib/rexml/text.rb:21 + def raw; end + + # If +raw+ is true, then REXML leaves the value alone + # + # source://rexml-3.2.5/lib/rexml/text.rb:21 + def raw=(_arg0); end + + # Returns the string value of this text node. This string is always + # escaped, meaning that it is a valid XML text node string, and all + # entities that can be escaped, have been inserted. This method respects + # the entity filter set in the constructor. + # + # # Assume that the entity "s" is defined to be "sean", and that the + # # entity "r" is defined to be "russell" + # t = Text.new( "< & sean russell", false, nil, false, ['s'] ) + # t.to_s #-> "< & &s; russell" + # t = Text.new( "< & &s; russell", false, nil, false ) + # t.to_s #-> "< & &s; russell" + # u = Text.new( "sean russell", false, nil, true ) + # u.to_s #-> "sean russell" + # + # source://rexml-3.2.5/lib/rexml/text.rb:228 + def to_s; end + + # Returns the string value of this text. This is the text without + # entities, as it might be used programmatically, or printed to the + # console. This ignores the 'raw' attribute setting, and any + # entity_filter. + # + # # Assume that the entity "s" is defined to be "sean", and that the + # # entity "r" is defined to be "russell" + # t = Text.new( "< & sean russell", false, nil, false, ['s'] ) + # t.value #-> "< & sean russell" + # t = Text.new( "< & &s; russell", false, nil, false ) + # t.value #-> "< & sean russell" + # u = Text.new( "sean russell", false, nil, true ) + # u.value #-> "sean russell" + # + # source://rexml-3.2.5/lib/rexml/text.rb:250 + def value; end + + # Sets the contents of this text node. This expects the text to be + # unnormalized. It returns self. + # + # e = Element.new( "a" ) + # e.add_text( "foo" ) # <a>foo</a> + # e[0].value = "bar" # <a>bar</a> + # e[0].value = "<a>" # <a><a></a> + # + # source://rexml-3.2.5/lib/rexml/text.rb:261 + def value=(val); end + + # source://rexml-3.2.5/lib/rexml/text.rb:267 + def wrap(string, width, addnewline = T.unsafe(nil)); end + + # == DEPRECATED + # See REXML::Formatters + # + # source://rexml-3.2.5/lib/rexml/text.rb:293 + def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end + + # Writes out text, substituting special characters beforehand. + # +out+ A String, IO, or any other object supporting <<( String ) + # +input+ the text to substitute and the write out + # + # z=utf8.unpack("U*") + # ascOut="" + # z.each{|r| + # if r < 0x100 + # ascOut.concat(r.chr) + # else + # ascOut.concat(sprintf("&#x%x;", r)) + # end + # } + # puts ascOut + # + # source://rexml-3.2.5/lib/rexml/text.rb:325 + def write_with_substitution(out, input); end + + # FIXME + # This probably won't work properly + # + # source://rexml-3.2.5/lib/rexml/text.rb:305 + def xpath; end + + private + + # source://rexml-3.2.5/lib/rexml/text.rb:338 + def clear_cache; end + + class << self + # check for illegal characters + # + # source://rexml-3.2.5/lib/rexml/text.rb:131 + def check(string, pattern, doctype); end + + # source://rexml-3.2.5/lib/rexml/text.rb:405 + def expand(ref, doctype, filter); end + + # Escapes all possible entities + # + # source://rexml-3.2.5/lib/rexml/text.rb:370 + def normalize(input, doctype = T.unsafe(nil), entity_filter = T.unsafe(nil)); end + + # Reads text, substituting entities + # + # source://rexml-3.2.5/lib/rexml/text.rb:344 + def read_with_substitution(input, illegal = T.unsafe(nil)); end + + # Unescapes all possible entities + # + # source://rexml-3.2.5/lib/rexml/text.rb:392 + def unnormalize(string, doctype = T.unsafe(nil), filter = T.unsafe(nil), illegal = T.unsafe(nil)); end + end +end + +# source://rexml-3.2.5/lib/rexml/undefinednamespaceexception.rb:4 +class REXML::UndefinedNamespaceException < ::REXML::ParseException + # @return [UndefinedNamespaceException] a new instance of UndefinedNamespaceException + # + # source://rexml-3.2.5/lib/rexml/undefinednamespaceexception.rb:5 + def initialize(prefix, source, parser); end +end + +# source://rexml-3.2.5/lib/rexml/validation/validationexception.rb:4 +class REXML::Validation::ValidationException < ::RuntimeError + # @return [ValidationException] a new instance of ValidationException + # + # source://rexml-3.2.5/lib/rexml/validation/validationexception.rb:5 + def initialize(msg); end +end + +# NEEDS DOCUMENTATION +# +# source://rexml-3.2.5/lib/rexml/xmldecl.rb:8 +class REXML::XMLDecl < ::REXML::Child + include ::REXML::Encoding + + # @return [XMLDecl] a new instance of XMLDecl + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:20 + def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:56 + def ==(other); end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:39 + def clone; end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:102 + def dowrite; end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:76 + def encoding=(enc); end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:106 + def inspect; end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:69 + def node_type; end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:98 + def nowrite; end + + # source://rexml-3.2.5/lib/rexml/encoding.rb:7 + def old_enc=(encoding); end + + # Returns the value of attribute standalone. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:17 + def stand_alone?; end + + # Returns the value of attribute standalone. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:17 + def standalone; end + + # Sets the attribute standalone + # + # @param value the value to set the attribute standalone to. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:17 + def standalone=(_arg0); end + + # Returns the value of attribute version. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:17 + def version; end + + # Sets the attribute version + # + # @param value the value to set the attribute version to. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:17 + def version=(_arg0); end + + # indent:: + # Ignored. There must be no whitespace before an XML declaration + # transitive:: + # Ignored + # ie_hack:: + # Ignored + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:49 + def write(writer, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end + + # Returns the value of attribute writeencoding. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:18 + def writeencoding; end + + # Returns the value of attribute writethis. + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:18 + def writethis; end + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:63 + def xmldecl(version, encoding, standalone); end + + private + + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:111 + def content(enc); end + + class << self + # Only use this if you do not want the XML declaration to be written; + # this object is ignored by the XML writer. Otherwise, instantiate your + # own XMLDecl and add it to the document. + # + # Note that XML 1.1 documents *must* include an XML declaration + # + # source://rexml-3.2.5/lib/rexml/xmldecl.rb:92 + def default; end + end +end + +# @private +# +# source://rexml-3.2.5/lib/rexml/xpath_parser.rb:959 +class REXML::XPathNode + # @return [XPathNode] a new instance of XPathNode + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:961 + def initialize(node, context = T.unsafe(nil)); end + + # Returns the value of attribute context. + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:960 + def context; end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:970 + def position; end + + # Returns the value of attribute raw_node. + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:960 + def raw_node; end +end + +# You don't want to use this class. Really. Use XPath, which is a wrapper +# for this class. Believe me. You don't want to poke around in here. +# There is strange, dark magic at work in this code. Beware. Go back! Go +# back while you still can! +# +# source://rexml-3.2.5/lib/rexml/xpath_parser.rb:54 +class REXML::XPathParser + include ::REXML::XMLTokens + + # @return [XPathParser] a new instance of XPathParser + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:60 + def initialize(strict: T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:94 + def []=(variable_name, value); end + + # Performs a depth-first (document order) XPath search, and returns the + # first match. This is the fastest, lightest way to return a single result. + # + # FIXME: This method is incomplete! + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:103 + def first(path_stack, node); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:84 + def get_first(path, nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:139 + def match(path_stack, nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:69 + def namespaces=(namespaces = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:79 + def parse(path, nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:89 + def predicate(path, nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:74 + def variables=(vars = T.unsafe(nil)); end + + private + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:775 + def child(nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:916 + def compare(a, operator, b); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:678 + def descendant(nodeset, include_self); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:689 + def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:938 + def each_unnode(nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:637 + def enter(tag, *args); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:815 + def equality_relational_compare(set1, op, set2); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:591 + def evaluate_predicate(expression, nodesets); end + + # Expr takes a stack of path elements and a set of nodes (either a Parent + # or an Array and returns an Array of matching nodes + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:175 + def expr(path_stack, nodeset, context = T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:582 + def filter_nodeset(nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:745 + def following(node); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:756 + def following_node_of(node); end + + # Returns a String namespace for a node, given a prefix + # The rules are: + # + # 1. Use the supplied namespace mapping first. + # 2. If no mapping was supplied, use the context node to look up the namespace + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:163 + def get_namespace(node, prefix); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:642 + def leave(tag, *args); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:763 + def next_sibling_node(node); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:477 + def node_test(path_stack, nodesets, any_type: T.unsafe(nil)); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:802 + def norm(b); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:890 + def normalize_compare_values(a, operator, b); end + + # Builds a nodeset of all of the preceding nodes of the supplied node, + # in reverse document order + # preceding:: includes every element in the document that precedes this node, + # except for ancestors + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:708 + def preceding(node); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:730 + def preceding_node_of(node); end + + # Reorders an array of nodes so that they are in document order + # It tries to do this efficiently. + # + # FIXME: I need to get rid of this, but the issue is that most of the XPath + # interpreter functions as a filter, which means that we lose context going + # in and out of function calls. If I knew what the index of the nodes was, + # I wouldn't have to do this. Maybe add a document IDX for each node? + # Problems with mutable documents. Or, rewrite everything. + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:655 + def sort(array_of_nodes, order); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:441 + def step(path_stack, any_type: T.unsafe(nil), order: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:154 + def strict?; end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:630 + def trace(*args); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:950 + def unnode(nodeset); end + + # source://rexml-3.2.5/lib/rexml/xpath_parser.rb:877 + def value_type(value); end +end diff --git a/sorbet/rbi/gems/rspec-core.rbi b/sorbet/rbi/gems/rspec-core.rbi deleted file mode 100644 index 474e7bd2..00000000 --- a/sorbet/rbi/gems/rspec-core.rbi +++ /dev/null @@ -1,1934 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi -# -# rspec-core-3.11.0 - -module RSpec - def self.clear_examples; end - def self.configuration; end - def self.configuration=(arg0); end - def self.configure; end - def self.const_missing(name); end - def self.context(*args, &example_group_block); end - def self.current_example; end - def self.current_example=(example); end - def self.current_scope; end - def self.current_scope=(scope); end - def self.describe(*args, &example_group_block); end - def self.example_group(*args, &example_group_block); end - def self.fcontext(*args, &example_group_block); end - def self.fdescribe(*args, &example_group_block); end - def self.reset; end - def self.shared_context(name, *args, &block); end - def self.shared_examples(name, *args, &block); end - def self.shared_examples_for(name, *args, &block); end - def self.world; end - def self.world=(arg0); end - def self.xcontext(*args, &example_group_block); end - def self.xdescribe(*args, &example_group_block); end - extend RSpec::Core::Warnings -end -module RSpec::Core - def self.path_to_executable; end -end -module RSpec::Core::Version -end -module RSpec::Core::Warnings - def deprecate(deprecated, data = nil); end - def warn_deprecation(message, opts = nil); end - def warn_with(message, options = nil); end -end -class RSpec::Core::Set - def <<(key); end - def clear; end - def delete(key); end - def each(&block); end - def empty?; end - def include?(key); end - def initialize(array = nil); end - def merge(values); end - include Enumerable -end -module RSpec::Core::FlatMap - def flat_map(array, &block); end - def self.flat_map(array, &block); end -end -class RSpec::Core::FilterManager - def add_ids(rerun_path, scoped_ids); end - def add_location(file_path, line_numbers); end - def add_path_to_arrays_filter(filter_key, path, values); end - def empty?; end - def exclude(*args); end - def exclude_only(*args); end - def exclude_with_low_priority(*args); end - def exclusions; end - def file_scoped_include?(ex_metadata, ids, locations); end - def include(*args); end - def include_only(*args); end - def include_with_low_priority(*args); end - def inclusions; end - def initialize; end - def prune(examples); end - def prune_conditionally_filtered_examples(examples); end -end -class RSpec::Core::FilterRules - def [](key); end - def add(updated); end - def add_with_low_priority(updated); end - def clear; end - def delete(key); end - def description; end - def each_pair(&block); end - def empty?; end - def fetch(*args, &block); end - def include_example?(example); end - def initialize(rules = nil); end - def opposite; end - def opposite=(arg0); end - def rules; end - def self.build; end - def use_only(updated); end -end -class RSpec::Core::InclusionRules < RSpec::Core::FilterRules - def add(*args); end - def add_with_low_priority(*args); end - def apply_standalone_filter(updated); end - def include_example?(example); end - def is_standalone_filter?(rules); end - def replace_filters(new_rules); end - def split_file_scoped_rules; end - def standalone?; end -end -module RSpec::Core::DSL - def self.change_global_dsl(&changes); end - def self.example_group_aliases; end - def self.expose_example_group_alias(name); end - def self.expose_example_group_alias_globally(method_name); end - def self.expose_globally!; end - def self.exposed_globally?; end - def self.remove_globally!; end - def self.top_level; end - def self.top_level=(arg0); end -end -module RSpec::Core::Formatters - def self.register(formatter_class, *notifications); end -end -module RSpec::Core::Formatters::ConsoleCodes - def config_colors_to_methods; end - def console_code_for(code_or_symbol); end - def self.config_colors_to_methods; end - def self.console_code_for(code_or_symbol); end - def self.wrap(text, code_or_symbol); end - def wrap(text, code_or_symbol); end -end -class RSpec::Core::Formatters::SnippetExtractor - def beginning_line_number; end - def expression_lines; end - def expression_node; end - def expression_outmost_node?(node); end - def initialize(source, beginning_line_number, max_line_count = nil); end - def line_range_of_expression; end - def line_range_of_location_nodes_in_expression; end - def location_nodes_at_beginning_line; end - def max_line_count; end - def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count = nil); end - def self.extract_line_at(file_path, line_number); end - def self.least_indentation_from(lines); end - def self.source_from_file(path); end - def source; end - def unclosed_tokens_in_line_range(line_range); end -end -class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < StandardError -end -class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < StandardError -end -class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < StandardError -end -class RSpec::Core::Formatters::SyntaxHighlighter - def color_enabled_implementation; end - def highlight(lines); end - def implementation; end - def initialize(configuration); end - def self.attempt_to_add_rspec_terms_to_coderay_keywords; end -end -module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation - def self.highlight_syntax(lines); end -end -module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation - def self.highlight_syntax(lines); end -end -class RSpec::Core::Formatters::ExceptionPresenter - def add_shared_group_lines(lines, colorizer); end - def backtrace_formatter; end - def colorized_formatted_backtrace(colorizer = nil); end - def colorized_message_lines(colorizer = nil); end - def description; end - def detail_formatter; end - def encoded_description(description); end - def encoded_string(string); end - def encoding_of(string); end - def example; end - def exception; end - def exception_backtrace; end - def exception_class_name(exception = nil); end - def exception_lines; end - def exception_message_string(exception); end - def extra_detail_formatter; end - def extra_failure_lines; end - def failure_lines; end - def failure_slash_error_lines; end - def final_exception(exception, previous = nil); end - def find_failed_line; end - def formatted_backtrace(exception = nil); end - def formatted_cause(exception); end - def formatted_message_and_backtrace(colorizer); end - def fully_formatted(failure_number, colorizer = nil); end - def fully_formatted_lines(failure_number, colorizer); end - def indent_lines(lines, failure_number); end - def initialize(exception, example, options = nil); end - def message_color; end - def message_lines; end - def read_failed_lines; end -end -class RSpec::Core::Formatters::ExceptionPresenter::Factory - def build; end - def initialize(example); end - def multiple_exception_summarizer(exception, prior_detail_formatter, color); end - def multiple_exceptions_error?(exception); end - def options; end - def pending_options; end - def sub_failure_list_formatter(exception, message_color); end - def with_multiple_error_options_as_needed(exception, options); end -end -module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter - def self.format_backtrace(*arg0); end -end -class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater - def initialize(parent); end - def with_truncated_backtrace(child); end -end -class RSpec::Core::MultipleExceptionError < StandardError - def aggregation_block_label; end - def aggregation_metadata; end - def all_exceptions; end - def exception_count_description; end - def failures; end - def initialize(*exceptions); end - def message; end - def other_errors; end - def summary; end - include RSpec::Core::MultipleExceptionError::InterfaceTag -end -module RSpec::Core::MultipleExceptionError::InterfaceTag - def add(exception); end - def self.for(ex); end -end -module RSpec::Core::ShellEscape - def conditionally_quote(id); end - def escape(shell_command); end - def quote(argument); end - def self.conditionally_quote(id); end - def self.escape(shell_command); end - def self.quote(argument); end - def self.shell_allows_unquoted_ids?; end - def shell_allows_unquoted_ids?; end -end -module RSpec::Core::Formatters::Helpers - def self.format_duration(duration); end - def self.format_seconds(float, precision = nil); end - def self.organize_ids(ids); end - def self.pluralize(count, string); end - def self.strip_trailing_zeroes(string); end -end -module RSpec::Core::Notifications -end -module RSpec::Core::Notifications::NullColorizer - def self.wrap(line, _code_or_symbol); end - def wrap(line, _code_or_symbol); end -end -class RSpec::Core::Notifications::StartNotification < Struct - def count; end - def count=(_); end - def load_time; end - def load_time=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::ExampleNotification < Struct - def example; end - def example=(_); end - def self.[](*arg0); end - def self.for(example); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::ExamplesNotification - def examples; end - def failed_examples; end - def failure_notifications; end - def format_examples(examples); end - def fully_formatted_failed_examples(colorizer = nil); end - def fully_formatted_pending_examples(colorizer = nil); end - def initialize(reporter); end - def notifications; end - def pending_examples; end - def pending_notifications; end -end -class RSpec::Core::Notifications::FailedExampleNotification < RSpec::Core::Notifications::ExampleNotification - def colorized_formatted_backtrace(colorizer = nil); end - def colorized_message_lines(colorizer = nil); end - def description; end - def exception; end - def formatted_backtrace; end - def fully_formatted(failure_number, colorizer = nil); end - def fully_formatted_lines(failure_number, colorizer = nil); end - def initialize(example, exception_presenter = nil); end - def message_lines; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::PendingExampleFixedNotification < RSpec::Core::Notifications::FailedExampleNotification -end -class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < RSpec::Core::Notifications::FailedExampleNotification -end -class RSpec::Core::Notifications::SkippedExampleNotification < RSpec::Core::Notifications::ExampleNotification - def fully_formatted(pending_number, colorizer = nil); end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::GroupNotification < Struct - def group; end - def group=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::MessageNotification < Struct - def message; end - def message=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::SeedNotification < Struct - def fully_formatted; end - def seed; end - def seed=(_); end - def seed_used?; end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def used; end - def used=(_); end -end -class RSpec::Core::Notifications::SummaryNotification < Struct - def colorized_rerun_commands(colorizer = nil); end - def colorized_totals_line(colorizer = nil); end - def duplicate_rerun_locations; end - def duration; end - def duration=(_); end - def errors_outside_of_examples_count; end - def errors_outside_of_examples_count=(_); end - def example_count; end - def examples; end - def examples=(_); end - def failed_examples; end - def failed_examples=(_); end - def failure_count; end - def formatted_duration; end - def formatted_load_time; end - def fully_formatted(colorizer = nil); end - def load_time; end - def load_time=(_); end - def pending_count; end - def pending_examples; end - def pending_examples=(_); end - def rerun_argument_for(example); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def totals_line; end - include RSpec::Core::ShellEscape -end -class RSpec::Core::Notifications::ProfileNotification - def calculate_slowest_groups; end - def duration; end - def examples; end - def initialize(duration, examples, number_of_examples, example_groups); end - def number_of_examples; end - def percentage; end - def slow_duration; end - def slowest_examples; end - def slowest_groups; end -end -class RSpec::Core::Notifications::DeprecationNotification < Struct - def call_site; end - def call_site=(_); end - def deprecated; end - def deprecated=(_); end - def message; end - def message=(_); end - def replacement; end - def replacement=(_); end - def self.[](*arg0); end - def self.from_hash(data); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Notifications::NullNotification -end -class RSpec::Core::Notifications::CustomNotification < Struct - def self.for(options = nil); end -end -class RSpec::Core::Reporter - def abort_with(msg, exit_status); end - def close; end - def close_after; end - def deprecation(hash); end - def ensure_listeners_ready; end - def example_failed(example); end - def example_finished(example); end - def example_group_finished(group); end - def example_group_started(group); end - def example_passed(example); end - def example_pending(example); end - def example_started(example); end - def examples; end - def exit_early(exit_code); end - def fail_fast_limit_met?; end - def failed_examples; end - def finish; end - def initialize(configuration); end - def message(message); end - def mute_profile_output?; end - def notify(event, notification); end - def notify_non_example_exception(exception, context_description); end - def pending_examples; end - def prepare_default(loader, output_stream, deprecation_stream); end - def publish(event, options = nil); end - def register_listener(listener, *notifications); end - def registered_listeners(notification); end - def report(expected_example_count); end - def seed_used?; end - def start(expected_example_count, time = nil); end - def stop; end -end -class RSpec::Core::NullReporter - def self.method_missing(*arg0); end -end -module RSpec::Core::Hooks - def after(*args, &block); end - def append_after(*args, &block); end - def append_before(*args, &block); end - def around(*args, &block); end - def before(*args, &block); end - def hooks; end - def prepend_after(*args, &block); end - def prepend_before(*args, &block); end -end -class RSpec::Core::Hooks::Hook < Struct - def block; end - def block=(_); end - def options; end - def options=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Hooks::BeforeHook < RSpec::Core::Hooks::Hook - def run(example); end -end -class RSpec::Core::Hooks::AfterHook < RSpec::Core::Hooks::Hook - def run(example); end -end -class RSpec::Core::Hooks::AfterContextHook < RSpec::Core::Hooks::Hook - def run(example); end -end -class RSpec::Core::Hooks::AroundHook < RSpec::Core::Hooks::Hook - def execute_with(example, procsy); end - def hook_description; end -end -class RSpec::Core::Hooks::HookCollections - def all_hooks_for(position, scope); end - def ensure_hooks_initialized_for(position, scope); end - def extract_scope_from(args); end - def hooks_for(position, scope); end - def initialize(owner, filterable_item_repo_class); end - def known_scope?(scope); end - def matching_hooks_for(position, scope, example_or_group); end - def normalized_scope_for(scope); end - def owner_parent_groups; end - def process(host, parent_groups, globals, position, scope); end - def processable_hooks_for(position, scope, host); end - def register(prepend_or_append, position, *args, &block); end - def register_global_singleton_context_hooks(example, globals); end - def register_globals(host, globals); end - def run(position, scope, example_or_group); end - def run_around_example_hooks_for(example); end - def run_example_hooks_for(example, position, each_method); end - def run_owned_hooks_for(position, scope, example_or_group); end - def scope_and_options_from(*args); end -end -module RSpec::Core::MemoizedHelpers - def __init_memoized; end - def __memoized; end - def enforce_value_expectation(matcher, method_name); end - def initialize(*arg0); end - def is_expected; end - def matcher_supports_value_expectations?(matcher); end - def self.define_helpers_on(example_group); end - def self.get_constant_or_yield(example_group, name); end - def self.module_for(example_group); end - def should(matcher = nil, message = nil); end - def should_not(matcher = nil, message = nil); end - def subject; end -end -class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized - def fetch_or_store(key); end - def initialize; end -end -class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized - def fetch_or_store(key); end - def initialize; end -end -class RSpec::Core::MemoizedHelpers::ContextHookMemoized - def self.fetch_or_store(key, &_block); end - def self.isolate_for_context_hook(example_group_instance); end -end -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < RSpec::Core::MemoizedHelpers::ContextHookMemoized - def self.article; end - def self.hook_expression; end - def self.hook_intention; end -end -class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < RSpec::Core::MemoizedHelpers::ContextHookMemoized - def self.article; end - def self.hook_expression; end - def self.hook_intention; end -end -module RSpec::Core::MemoizedHelpers::ClassMethods - def let!(name, &block); end - def let(name, &block); end - def subject!(name = nil, &block); end - def subject(name = nil, &block); end -end -module RSpec::Core::Metadata - def self.ascend(metadata); end - def self.ascending(metadata); end - def self.build_hash_from(args, warn_about_example_group_filtering = nil); end - def self.deep_hash_dup(object); end - def self.id_from(metadata); end - def self.location_tuple_from(metadata); end - def self.relative_path(line); end - def self.relative_path_regex; end -end -class RSpec::Core::Metadata::HashPopulator - def block; end - def build_description_from(parent_description = nil, my_description = nil); end - def build_scoped_id_for(file_path); end - def description_args; end - def description_separator(parent_part, child_part); end - def ensure_valid_user_keys; end - def file_path_and_line_number_from(backtrace); end - def initialize(metadata, user_metadata, index_provider, description_args, block); end - def metadata; end - def populate; end - def populate_location_attributes; end - def user_metadata; end -end -class RSpec::Core::Metadata::ExampleHash < RSpec::Core::Metadata::HashPopulator - def described_class; end - def full_description; end - def self.create(group_metadata, user_metadata, index_provider, description, block); end -end -class RSpec::Core::Metadata::ExampleGroupHash < RSpec::Core::Metadata::HashPopulator - def described_class; end - def full_description; end - def self.backwards_compatibility_default_proc(&example_group_selector); end - def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end - def self.hash_with_backwards_compatibility_default_proc; end -end -module RSpec::Core::HashImitatable - def <(*args, &block); end - def <=(*args, &block); end - def >(*args, &block); end - def >=(*args, &block); end - def [](key); end - def []=(key, value); end - def all?(*args, &block); end - def any?(*args, &block); end - def assoc(*args, &block); end - def chain(*args, &block); end - def chunk(*args, &block); end - def chunk_while(*args, &block); end - def clear(*args, &block); end - def collect(*args, &block); end - def collect_concat(*args, &block); end - def compact!(*args, &block); end - def compact(*args, &block); end - def compare_by_identity(*args, &block); end - def compare_by_identity?(*args, &block); end - def count(*args, &block); end - def cycle(*args, &block); end - def deconstruct_keys(*args, &block); end - def default(*args, &block); end - def default=(*args, &block); end - def default_proc(*args, &block); end - def default_proc=(*args, &block); end - def delete(*args, &block); end - def delete_if(*args, &block); end - def detect(*args, &block); end - def dig(*args, &block); end - def directly_supports_attribute?(name); end - def drop(*args, &block); end - def drop_while(*args, &block); end - def each(*args, &block); end - def each_cons(*args, &block); end - def each_entry(*args, &block); end - def each_key(*args, &block); end - def each_pair(*args, &block); end - def each_slice(*args, &block); end - def each_value(*args, &block); end - def each_with_index(*args, &block); end - def each_with_object(*args, &block); end - def empty?(*args, &block); end - def entries(*args, &block); end - def extra_hash_attributes; end - def fetch(*args, &block); end - def fetch_values(*args, &block); end - def filter!(*args, &block); end - def filter(*args, &block); end - def filter_map(*args, &block); end - def find(*args, &block); end - def find_all(*args, &block); end - def find_index(*args, &block); end - def first(*args, &block); end - def flat_map(*args, &block); end - def flatten(*args, &block); end - def get_value(name); end - def grep(*args, &block); end - def grep_v(*args, &block); end - def group_by(*args, &block); end - def has_key?(*args, &block); end - def has_value?(*args, &block); end - def hash_for_delegation; end - def include?(*args, &block); end - def index(*args, &block); end - def inject(*args, &block); end - def invert(*args, &block); end - def issue_deprecation(_method_name, *_args); end - def keep_if(*args, &block); end - def key(*args, &block); end - def key?(*args, &block); end - def keys(*args, &block); end - def lazy(*args, &block); end - def length(*args, &block); end - def map(*args, &block); end - def max(*args, &block); end - def max_by(*args, &block); end - def member?(*args, &block); end - def merge!(*args, &block); end - def merge(*args, &block); end - def min(*args, &block); end - def min_by(*args, &block); end - def minmax(*args, &block); end - def minmax_by(*args, &block); end - def none?(*args, &block); end - def one?(*args, &block); end - def partition(*args, &block); end - def rassoc(*args, &block); end - def reduce(*args, &block); end - def rehash(*args, &block); end - def reject!(*args, &block); end - def reject(*args, &block); end - def replace(*args, &block); end - def reverse_each(*args, &block); end - def select!(*args, &block); end - def select(*args, &block); end - def self.included(klass); end - def set_value(name, value); end - def shift(*args, &block); end - def size(*args, &block); end - def slice(*args, &block); end - def slice_after(*args, &block); end - def slice_before(*args, &block); end - def slice_when(*args, &block); end - def sort(*args, &block); end - def sort_by(*args, &block); end - def store(*args, &block); end - def sum(*args, &block); end - def take(*args, &block); end - def take_while(*args, &block); end - def tally(*args, &block); end - def to_a(*args, &block); end - def to_h; end - def to_hash(*args, &block); end - def to_proc(*args, &block); end - def to_set(*args, &block); end - def transform_keys!(*args, &block); end - def transform_keys(*args, &block); end - def transform_values!(*args, &block); end - def transform_values(*args, &block); end - def uniq(*args, &block); end - def update(*args, &block); end - def value?(*args, &block); end - def values(*args, &block); end - def values_at(*args, &block); end - def zip(*args, &block); end -end -module RSpec::Core::HashImitatable::ClassMethods - def attr_accessor(*names); end - def hash_attribute_names; end -end -class RSpec::Core::LegacyExampleGroupHash - def directly_supports_attribute?(name); end - def get_value(name); end - def initialize(metadata); end - def set_value(name, value); end - def to_h; end - extend RSpec::Core::HashImitatable::ClassMethods - include RSpec::Core::HashImitatable -end -module RSpec::Core::MetadataFilter - def self.apply?(predicate, filters, metadata); end - def self.filter_applies?(key, filter_value, metadata); end - def self.filter_applies_to_any_value?(key, value, metadata); end - def self.filters_apply?(key, value, metadata); end - def self.id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end - def self.location_filter_applies?(locations, metadata); end - def self.proc_filter_applies?(key, proc, metadata); end - def self.silence_metadata_example_group_deprecations; end -end -module RSpec::Core::FilterableItemRepository -end -class RSpec::Core::FilterableItemRepository::UpdateOptimized - def append(item, metadata); end - def delete(item, metadata); end - def initialize(applies_predicate); end - def items_and_filters; end - def items_for(request_meta); end - def prepend(item, metadata); end -end -class RSpec::Core::FilterableItemRepository::QueryOptimized < RSpec::Core::FilterableItemRepository::UpdateOptimized - def append(item, metadata); end - def applicable_metadata_from(metadata); end - def delete(item, metadata); end - def find_items_for(request_meta); end - def handle_mutation(metadata); end - def initialize(applies_predicate); end - def items_for(metadata); end - def prepend(item, metadata); end - def proc_keys_from(metadata); end - def reconstruct_caches; end -end -module RSpec::Core::Pending - def pending(message = nil); end - def self.mark_fixed!(example); end - def self.mark_pending!(example, message_or_bool); end - def self.mark_skipped!(example, message_or_bool); end - def skip(message = nil); end -end -class RSpec::Core::Pending::SkipDeclaredInExample < StandardError - def argument; end - def initialize(argument); end -end -class RSpec::Core::Pending::PendingExampleFixedError < StandardError -end -class RSpec::Core::Formatters::Loader - def add(formatter_to_use, *paths); end - def built_in_formatter(key); end - def custom_formatter(formatter_ref); end - def default_formatter; end - def default_formatter=(arg0); end - def duplicate_formatter_exists?(new_formatter); end - def existing_formatter_implements?(notification); end - def find_formatter(formatter_to_use); end - def formatters; end - def has_matching_output?(formatter, new_formatter); end - def initialize(reporter); end - def notifications_for(formatter_class); end - def open_stream(path_or_wrapper); end - def path_for(const_ref); end - def prepare_default(output_stream, deprecation_stream); end - def register(formatter, notifications); end - def reporter; end - def self.formatters; end - def setup_default(output_stream, deprecation_stream); end - def string_const?(str); end - def underscore(camel_cased_word); end - def underscore_with_fix_for_non_standard_rspec_naming(string); end -end -module RSpec::Core::Ordering -end -class RSpec::Core::Ordering::Identity - def order(items); end -end -class RSpec::Core::Ordering::Random - def initialize(configuration); end - def jenkins_hash_digest(string); end - def order(items); end - def used?; end -end -class RSpec::Core::Ordering::RecentlyModified - def order(list); end -end -class RSpec::Core::Ordering::Custom - def initialize(callable); end - def order(list); end -end -class RSpec::Core::Ordering::Registry - def fetch(name, &fallback); end - def initialize(configuration); end - def register(sym, strategy); end - def used_random_seed?; end -end -class RSpec::Core::Ordering::ConfigurationManager - def force(hash); end - def initialize; end - def order=(type); end - def ordering_registry; end - def register_ordering(name, strategy = nil); end - def seed; end - def seed=(seed); end - def seed_used?; end -end -class RSpec::Core::World - def all_example_groups; end - def all_examples; end - def announce_exclusion_filter(announcements); end - def announce_filters; end - def announce_inclusion_filter(announcements); end - def descending_declaration_line_numbers_by_file; end - def everything_filtered_message; end - def example_count(groups = nil); end - def example_group_counts_by_spec_file; end - def example_groups; end - def exclusion_filter; end - def fail_if_config_and_cli_options_invalid; end - def filter_manager; end - def filtered_examples; end - def inclusion_filter; end - def initialize(configuration = nil); end - def non_example_failure; end - def non_example_failure=(arg0); end - def num_example_groups_defined_in(file); end - def ordered_example_groups; end - def preceding_declaration_line(absolute_file_name, filter_line); end - def prepare_example_filtering; end - def record(example_group); end - def registered_example_group_files; end - def report_filter_message(message); end - def reporter; end - def reset; end - def rspec_is_quitting; end - def rspec_is_quitting=(arg0); end - def shared_example_group_registry; end - def source_from_file(path); end - def syntax_highlighter; end - def traverse_example_group_trees_until(&block); end - def wants_to_quit; end - def wants_to_quit=(arg0); end -end -module RSpec::Core::World::Null - def self.all_example_groups; end - def self.example_groups; end - def self.non_example_failure; end - def self.non_example_failure=(_); end - def self.registered_example_group_files; end - def self.traverse_example_group_trees_until; end -end -class RSpec::Core::BacktraceFormatter - def backtrace_line(line); end - def exclude?(line); end - def exclusion_patterns; end - def exclusion_patterns=(arg0); end - def filter_gem(gem_name); end - def format_backtrace(backtrace, options = nil); end - def full_backtrace=(arg0); end - def full_backtrace?; end - def inclusion_patterns; end - def inclusion_patterns=(arg0); end - def initialize; end - def matches?(patterns, line); end -end -module RSpec::Core::RubyProject - def add_dir_to_load_path(dir); end - def add_to_load_path(*dirs); end - def ascend_until; end - def determine_root; end - def find_first_parent_containing(dir); end - def root; end - def self.add_dir_to_load_path(dir); end - def self.add_to_load_path(*dirs); end - def self.ascend_until; end - def self.determine_root; end - def self.find_first_parent_containing(dir); end - def self.root; end -end -class RSpec::Core::Formatters::DeprecationFormatter - def count; end - def deprecation(notification); end - def deprecation_message_for(data); end - def deprecation_stream; end - def deprecation_summary(_notification); end - def initialize(deprecation_stream, summary_stream); end - def output; end - def printer; end - def summary_stream; end -end -class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < Struct - def deprecation_type_for(data); end - def initialize(data); end - def output_formatted(str); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def to_s; end - def too_many_warnings_message; end - def type; end - def type=(_); end -end -class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < Struct - def initialize(data); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def to_s; end - def too_many_warnings_message; end - def type; end - def type=(_); end -end -class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter - def deprecation_formatter; end - def deprecation_stream; end - def deprecation_summary; end - def initialize(deprecation_stream, summary_stream, deprecation_formatter); end - def print_deprecation_message(data); end - def summary_stream; end -end -class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter - def deprecation_formatter; end - def deprecation_stream; end - def deprecation_summary; end - def initialize(deprecation_stream, summary_stream, deprecation_formatter); end - def print_deferred_deprecation_warnings; end - def print_deprecation_message(data); end - def stash_deprecation_message(deprecation_message); end - def summary_stream; end -end -class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream - def puts(message); end - def summarize(summary_stream, deprecation_count); end -end -class RSpec::Core::Formatters::DeprecationFormatter::FileStream - def initialize(file); end - def puts(*args); end - def summarize(summary_stream, deprecation_count); end -end -class RSpec::Core::DeprecationError < StandardError -end -class RSpec::Core::OutputWrapper - def <<(*args, &block); end - def advise(*args, &block); end - def autoclose=(*args, &block); end - def autoclose?(*args, &block); end - def beep(*args, &block); end - def binmode(*args, &block); end - def binmode?(*args, &block); end - def bytes(*args, &block); end - def chars(*args, &block); end - def check_winsize_changed(*args, &block); end - def clear_screen(*args, &block); end - def close(*args, &block); end - def close_on_exec=(*args, &block); end - def close_on_exec?(*args, &block); end - def close_read(*args, &block); end - def close_write(*args, &block); end - def closed?(*args, &block); end - def codepoints(*args, &block); end - def console_mode(*args, &block); end - def console_mode=(*args, &block); end - def cooked!(*args, &block); end - def cooked(*args, &block); end - def cursor(*args, &block); end - def cursor=(*args, &block); end - def cursor_down(*args, &block); end - def cursor_left(*args, &block); end - def cursor_right(*args, &block); end - def cursor_up(*args, &block); end - def each(*args, &block); end - def each_byte(*args, &block); end - def each_char(*args, &block); end - def each_codepoint(*args, &block); end - def each_line(*args, &block); end - def echo=(*args, &block); end - def echo?(*args, &block); end - def eof(*args, &block); end - def eof?(*args, &block); end - def erase_line(*args, &block); end - def erase_screen(*args, &block); end - def external_encoding(*args, &block); end - def fcntl(*args, &block); end - def fdatasync(*args, &block); end - def fileno(*args, &block); end - def flush(*args, &block); end - def fsync(*args, &block); end - def getbyte(*args, &block); end - def getc(*args, &block); end - def getch(*args, &block); end - def getpass(*args, &block); end - def gets(*args, &block); end - def goto(*args, &block); end - def goto_column(*args, &block); end - def iflush(*args, &block); end - def initialize(output); end - def inspect(*args, &block); end - def internal_encoding(*args, &block); end - def ioctl(*args, &block); end - def ioflush(*args, &block); end - def isatty(*args, &block); end - def lineno(*args, &block); end - def lineno=(*args, &block); end - def lines(*args, &block); end - def method_missing(name, *args, &block); end - def noecho(*args, &block); end - def nread(*args, &block); end - def oflush(*args, &block); end - def output; end - def output=(arg0); end - def pathconf(*args, &block); end - def pid(*args, &block); end - def pos(*args, &block); end - def pos=(*args, &block); end - def pread(*args, &block); end - def pressed?(*args, &block); end - def print(*args, &block); end - def printf(*args, &block); end - def putc(*args, &block); end - def puts(*args, &block); end - def pwrite(*args, &block); end - def raw!(*args, &block); end - def raw(*args, &block); end - def read(*args, &block); end - def read_nonblock(*args, &block); end - def readbyte(*args, &block); end - def readchar(*args, &block); end - def readline(*args, &block); end - def readlines(*args, &block); end - def readpartial(*args, &block); end - def ready?(*args, &block); end - def reopen(*args, &block); end - def respond_to?(name, priv = nil); end - def rewind(*args, &block); end - def scroll_backward(*args, &block); end - def scroll_forward(*args, &block); end - def seek(*args, &block); end - def set_encoding(*args, &block); end - def set_encoding_by_bom(*args, &block); end - def stat(*args, &block); end - def sync(*args, &block); end - def sync=(*args, &block); end - def sysread(*args, &block); end - def sysseek(*args, &block); end - def syswrite(*args, &block); end - def tell(*args, &block); end - def to_i(*args, &block); end - def to_io(*args, &block); end - def tty?(*args, &block); end - def ungetbyte(*args, &block); end - def ungetc(*args, &block); end - def wait(*args, &block); end - def wait_readable(*args, &block); end - def wait_writable(*args, &block); end - def winsize(*args, &block); end - def winsize=(*args, &block); end - def write(*args, &block); end - def write_nonblock(*args, &block); end -end -class RSpec::Core::Configuration - def absolute_pattern?(pattern); end - def add_formatter(formatter, output = nil); end - def add_hook_to_existing_matching_groups(meta, scope, &block); end - def add_setting(name, opts = nil); end - def after(scope = nil, *meta, &block); end - def alias_example_group_to(new_name, *args); end - def alias_example_to(name, *args); end - def alias_it_behaves_like_to(new_name, report_label = nil); end - def alias_it_should_behave_like_to(new_name, report_label = nil); end - def append_after(scope = nil, *meta, &block); end - def append_before(scope = nil, *meta, &block); end - def apply_derived_metadata_to(metadata); end - def around(scope = nil, *meta, &block); end - def assert_no_example_groups_defined(config_option); end - def backtrace_exclusion_patterns; end - def backtrace_exclusion_patterns=(patterns); end - def backtrace_formatter; end - def backtrace_inclusion_patterns; end - def backtrace_inclusion_patterns=(patterns); end - def before(scope = nil, *meta, &block); end - def bisect_runner; end - def bisect_runner=(value); end - def bisect_runner_class; end - def clear_values_derived_from_example_status_persistence_file_path; end - def color; end - def color=(arg0); end - def color_enabled?(output = nil); end - def color_mode; end - def color_mode=(arg0); end - def command; end - def conditionally_disable_expectations_monkey_patching; end - def conditionally_disable_mocks_monkey_patching; end - def configure_example(example, example_hooks); end - def configure_expectation_framework; end - def configure_group(group); end - def configure_group_with(group, module_list, application_method); end - def configure_mock_framework; end - def default_color; end - def default_color=(arg0); end - def default_color?; end - def default_formatter; end - def default_formatter=(value); end - def default_path; end - def default_path=(path); end - def default_path?; end - def define_built_in_hooks; end - def define_derived_metadata(*filters, &block); end - def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end - def deprecation_stream; end - def deprecation_stream=(value); end - def detail_color; end - def detail_color=(arg0); end - def detail_color?; end - def disable_monkey_patching!; end - def disable_monkey_patching; end - def disable_monkey_patching=(arg0); end - def drb; end - def drb=(arg0); end - def drb?; end - def drb_port; end - def drb_port=(arg0); end - def drb_port?; end - def dry_run; end - def dry_run=(arg0); end - def dry_run?; end - def error_exit_code; end - def error_exit_code=(arg0); end - def error_exit_code?; end - def error_stream; end - def error_stream=(arg0); end - def error_stream?; end - def example_status_persistence_file_path; end - def example_status_persistence_file_path=(value); end - def exclude_pattern; end - def exclude_pattern=(value); end - def exclusion_filter; end - def exclusion_filter=(filter); end - def expect_with(*frameworks); end - def expectation_framework=(framework); end - def expectation_frameworks; end - def expose_current_running_example_as(method_name); end - def expose_dsl_globally=(value); end - def expose_dsl_globally?; end - def extend(mod, *filters); end - def extract_location(path); end - def fail_fast; end - def fail_fast=(value); end - def fail_if_no_examples; end - def fail_if_no_examples=(arg0); end - def fail_if_no_examples?; end - def failure_color; end - def failure_color=(arg0); end - def failure_color?; end - def failure_exit_code; end - def failure_exit_code=(arg0); end - def failure_exit_code?; end - def file_glob_from(path, pattern); end - def files_or_directories_to_run=(*files); end - def files_to_run; end - def files_to_run=(arg0); end - def filter; end - def filter=(filter); end - def filter_gems_from_backtrace(*gem_names); end - def filter_manager; end - def filter_manager=(arg0); end - def filter_run(*args); end - def filter_run_excluding(*args); end - def filter_run_including(*args); end - def filter_run_when_matching(*args); end - def fixed_color; end - def fixed_color=(arg0); end - def fixed_color?; end - def force(hash); end - def format_docstrings(&block); end - def format_docstrings_block; end - def formatter=(formatter, output = nil); end - def formatter_loader; end - def formatters; end - def full_backtrace=(true_or_false); end - def full_backtrace?; end - def full_description; end - def full_description=(description); end - def gather_directories(path); end - def get_files_to_run(paths); end - def get_matching_files(path, pattern); end - def handle_suite_hook(scope, meta); end - def hooks; end - def in_project_source_dir_regex; end - def include(mod, *filters); end - def include_context(shared_group_name, *filters); end - def inclusion_filter; end - def inclusion_filter=(filter); end - def initialize; end - def last_run_statuses; end - def libs; end - def libs=(libs); end - def load_file_handling_errors(method, file); end - def load_spec_files; end - def loaded_spec_files; end - def max_displayed_failure_line_count; end - def max_displayed_failure_line_count=(arg0); end - def max_displayed_failure_line_count?; end - def metadata_applies_to_group?(meta, group); end - def mock_framework; end - def mock_framework=(framework); end - def mock_with(framework); end - def on_example_group_definition(&block); end - def on_example_group_definition_callbacks; end - def on_existing_matching_groups(meta); end - def only_failures; end - def only_failures?; end - def only_failures_but_not_configured?; end - def order=(*args, &block); end - def ordering_manager; end - def ordering_registry(*args, &block); end - def output_stream; end - def output_stream=(value); end - def output_to_tty?(output = nil); end - def output_wrapper; end - def paths_to_check(paths); end - def pattern; end - def pattern=(value); end - def pattern_might_load_specs_from_vendored_dirs?; end - def pending_color; end - def pending_color=(arg0); end - def pending_color?; end - def prepend(mod, *filters); end - def prepend_after(scope = nil, *meta, &block); end - def prepend_before(scope = nil, *meta, &block); end - def profile_examples; end - def profile_examples=(arg0); end - def profile_examples?; end - def project_source_dirs; end - def project_source_dirs=(arg0); end - def project_source_dirs?; end - def raise_errors_for_deprecations!; end - def raise_on_warning=(value); end - def register_ordering(*args, &block); end - def reporter; end - def requires; end - def requires=(paths); end - def reset; end - def reset_filters; end - def reset_reporter; end - def rspec_expectations_loaded?; end - def rspec_mocks_loaded?; end - def run_all_when_everything_filtered; end - def run_all_when_everything_filtered=(arg0); end - def run_all_when_everything_filtered?; end - def run_suite_hooks(hook_description, hooks); end - def safe_extend(mod, host); end - def safe_include(mod, host); end - def safe_prepend(mod, host); end - def seed(*args, &block); end - def seed=(*args, &block); end - def seed_used?(*args, &block); end - def self.add_read_only_setting(name, opts = nil); end - def self.add_setting(name, opts = nil); end - def self.define_alias(name, alias_name); end - def self.define_predicate(name); end - def self.define_reader(name); end - def self.delegate_to_ordering_manager(*methods); end - def shared_context_metadata_behavior; end - def shared_context_metadata_behavior=(value); end - def silence_filter_announcements; end - def silence_filter_announcements=(arg0); end - def silence_filter_announcements?; end - def spec_files_with_failures; end - def start_time; end - def start_time=(arg0); end - def start_time?; end - def static_config_filter_manager; end - def static_config_filter_manager=(arg0); end - def success_color; end - def success_color=(arg0); end - def success_color?; end - def threadsafe; end - def threadsafe=(arg0); end - def threadsafe?; end - def treat_symbols_as_metadata_keys_with_true_values=(_value); end - def tty; end - def tty=(arg0); end - def tty?; end - def update_pattern_attr(name, value); end - def value_for(key); end - def warnings=(value); end - def warnings?; end - def when_first_matching_example_defined(*filters); end - def with_suite_hooks; end - def world; end - def world=(arg0); end - include RSpec::Core::Configuration::Readers - include RSpec::Core::Hooks -end -module RSpec::Core::Configuration::Readers - def default_color; end - def default_path; end - def deprecation_stream; end - def detail_color; end - def drb; end - def drb_port; end - def dry_run; end - def error_exit_code; end - def error_stream; end - def example_status_persistence_file_path; end - def exclude_pattern; end - def fail_fast; end - def fail_if_no_examples; end - def failure_color; end - def failure_exit_code; end - def fixed_color; end - def libs; end - def max_displayed_failure_line_count; end - def only_failures; end - def output_stream; end - def pattern; end - def pending_color; end - def project_source_dirs; end - def requires; end - def run_all_when_everything_filtered; end - def shared_context_metadata_behavior; end - def silence_filter_announcements; end - def start_time; end - def success_color; end - def threadsafe; end - def tty; end -end -class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < StandardError -end -class RSpec::Core::Configuration::DeprecationReporterBuffer - def deprecation(*args); end - def initialize; end - def play_onto(reporter); end -end -module RSpec::Core::Configuration::ExposeCurrentExample -end -class RSpec::Core::Parser - def add_tag_filter(options, filter_type, tag_name, value = nil); end - def configure_only_failures(options); end - def initialize(original_args); end - def original_args; end - def parse(source = nil); end - def parser(options); end - def self.parse(args, source = nil); end - def set_fail_fast(options, value); end -end -class RSpec::Core::ConfigurationOptions - def args; end - def args_from_options_file(path); end - def command_line_options; end - def configure(config); end - def configure_filter_manager(filter_manager); end - def custom_options; end - def custom_options_file; end - def env_options; end - def file_options; end - def force?(key); end - def global_options; end - def global_options_file; end - def home_options_file_path; end - def initialize(args); end - def load_formatters_into(config); end - def local_options; end - def local_options_file; end - def options; end - def options_file_as_erb_string(path); end - def options_from(path); end - def order(keys); end - def organize_options; end - def parse_args_ignoring_files_or_dirs_to_run(args, source); end - def process_options_into(config); end - def project_options; end - def project_options_file; end - def resolve_xdg_config_home; end - def xdg_options_file_if_exists; end - def xdg_options_file_path; end -end -class RSpec::Core::Runner - def configuration; end - def configure(err, out); end - def exit_code(examples_passed = nil); end - def initialize(options, configuration = nil, world = nil); end - def options; end - def persist_example_statuses; end - def run(err, out); end - def run_specs(example_groups); end - def self.autorun; end - def self.autorun_disabled?; end - def self.disable_autorun!; end - def self.handle_interrupt; end - def self.installed_at_exit?; end - def self.invoke; end - def self.perform_at_exit; end - def self.run(args, err = nil, out = nil); end - def self.running_in_drb?; end - def self.trap_interrupt; end - def setup(err, out); end - def world; end -end -module RSpec::Core::Invocations -end -class RSpec::Core::Invocations::InitializeProject - def call(*_args); end -end -class RSpec::Core::Invocations::DRbWithFallback - def call(options, err, out); end -end -class RSpec::Core::Invocations::Bisect - def bisect_formatter_klass_for(argument); end - def call(options, err, out); end -end -class RSpec::Core::Invocations::PrintVersion - def call(_options, _err, out); end -end -class RSpec::Core::Invocations::PrintHelp < Struct - def call(_options, _err, out); end - def hidden_options; end - def hidden_options=(_); end - def parser; end - def parser=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Example - def assign_generated_description; end - def clock; end - def clock=(arg0); end - def description; end - def display_exception; end - def display_exception=(ex); end - def duplicate_with(metadata_overrides = nil); end - def example_group; end - def example_group_instance; end - def exception; end - def execution_result; end - def fail_with_exception(reporter, exception); end - def file_path; end - def finish(reporter); end - def full_description; end - def generate_description; end - def hooks; end - def id; end - def initialize(example_group_class, description, user_metadata, example_block = nil); end - def inspect; end - def inspect_output; end - def instance_exec(*args, &block); end - def location; end - def location_description; end - def location_rerun_argument; end - def metadata; end - def mocks_need_verification?; end - def pending; end - def pending?; end - def record_finished(status, reporter); end - def reporter; end - def rerun_argument; end - def run(example_group_instance, reporter); end - def run_after_example; end - def run_before_example; end - def self.delegate_to_metadata(key); end - def self.parse_id(id); end - def set_aggregate_failures_exception(exception); end - def set_exception(exception); end - def skip; end - def skip_with_exception(reporter, exception); end - def skipped?; end - def start(reporter); end - def to_s; end - def update_inherited_metadata(updates); end - def verify_mocks; end - def with_around_and_singleton_context_hooks; end - def with_around_example_hooks; end -end -class RSpec::Core::Example::Procsy - def <<(*a, &b); end - def ===(*a, &b); end - def >>(*a, &b); end - def [](*a, &b); end - def arity(*a, &b); end - def binding(*a, &b); end - def call(*args, &block); end - def clock(*a, &b); end - def clock=(*a, &b); end - def clone(*a, &b); end - def curry(*a, &b); end - def description(*a, &b); end - def dup(*a, &b); end - def duplicate_with(*a, &b); end - def example; end - def example_group(*a, &b); end - def example_group_instance(*a, &b); end - def exception(*a, &b); end - def executed?; end - def execution_result(*a, &b); end - def file_path(*a, &b); end - def full_description(*a, &b); end - def hash(*a, &b); end - def id(*a, &b); end - def initialize(example, &block); end - def inspect; end - def inspect_output(*a, &b); end - def lambda?(*a, &b); end - def location(*a, &b); end - def location_rerun_argument(*a, &b); end - def metadata(*a, &b); end - def parameters(*a, &b); end - def pending(*a, &b); end - def pending?(*a, &b); end - def reporter(*a, &b); end - def rerun_argument(*a, &b); end - def ruby2_keywords(*a, &b); end - def run(*args, &block); end - def skip(*a, &b); end - def skipped?(*a, &b); end - def source_location(*a, &b); end - def to_proc; end - def update_inherited_metadata(*a, &b); end - def wrap(&block); end - def yield(*a, &b); end -end -class RSpec::Core::Example::ExecutionResult - def calculate_run_time(finished_at); end - def ensure_timing_set(clock); end - def example_skipped?; end - def exception; end - def exception=(arg0); end - def finished_at; end - def finished_at=(arg0); end - def get_value(name); end - def hash_for_delegation; end - def issue_deprecation(_method_name, *_args); end - def pending_exception; end - def pending_exception=(arg0); end - def pending_fixed; end - def pending_fixed=(arg0); end - def pending_fixed?; end - def pending_message; end - def pending_message=(arg0); end - def record_finished(status, finished_at); end - def run_time; end - def run_time=(arg0); end - def set_value(name, value); end - def started_at; end - def started_at=(arg0); end - def status; end - def status=(arg0); end - extend RSpec::Core::HashImitatable::ClassMethods - include RSpec::Core::HashImitatable -end -class RSpec::Core::SuiteHookContext < RSpec::Core::Example - def initialize(hook_description, reporter); end - def set_exception(exception); end -end -class RSpec::Core::SharedExampleGroupModule < Module - def definition; end - def include_in(klass, inclusion_line, args, customization_block); end - def included(klass); end - def initialize(description, definition, metadata); end - def inspect; end - def to_s; end -end -module RSpec::Core::SharedExampleGroup - def shared_context(name, *args, &block); end - def shared_examples(name, *args, &block); end - def shared_examples_for(name, *args, &block); end -end -module RSpec::Core::SharedExampleGroup::TopLevelDSL - def self.definitions; end - def self.expose_globally!; end - def self.exposed_globally?; end - def self.remove_globally!; end -end -class RSpec::Core::SharedExampleGroup::Registry - def add(context, name, *metadata_args, &block); end - def ensure_block_has_source_location(_block); end - def find(lookup_contexts, name); end - def formatted_location(block); end - def legacy_add(context, name, *metadata_args, &block); end - def shared_example_groups; end - def valid_name?(candidate); end - def warn_if_key_taken(context, key, new_block); end -end -class RSpec::Core::ExampleGroup - def described_class; end - def initialize(inspect_output = nil); end - def inspect; end - def method_missing(name, *args); end - def self.add_example(example); end - def self.before_context_ivars; end - def self.children; end - def self.context(*args, &example_group_block); end - def self.currently_executing_a_context_hook?; end - def self.declaration_locations; end - def self.define_example_group_method(name, metadata = nil); end - def self.define_example_method(name, extra_options = nil); end - def self.define_nested_shared_group_method(new_name, report_label = nil); end - def self.delegate_to_metadata(*names); end - def self.descendant_filtered_examples; end - def self.descendants; end - def self.describe(*args, &example_group_block); end - def self.described_class; end - def self.description; end - def self.each_instance_variable_for_example(group); end - def self.ensure_example_groups_are_configured; end - def self.example(*all_args, &block); end - def self.example_group(*args, &example_group_block); end - def self.examples; end - def self.fcontext(*args, &example_group_block); end - def self.fdescribe(*args, &example_group_block); end - def self.fexample(*all_args, &block); end - def self.file_path; end - def self.filtered_examples; end - def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end - def self.fit(*all_args, &block); end - def self.focus(*all_args, &block); end - def self.for_filtered_examples(reporter, &block); end - def self.fspecify(*all_args, &block); end - def self.id; end - def self.idempotently_define_singleton_method(name, &definition); end - def self.include_context(name, *args, &block); end - def self.include_examples(name, *args, &block); end - def self.it(*all_args, &block); end - def self.it_behaves_like(name, *args, &customization_block); end - def self.it_should_behave_like(name, *args, &customization_block); end - def self.location; end - def self.metadata; end - def self.method_missing(name, *args); end - def self.next_runnable_index_for(file); end - def self.ordering_strategy; end - def self.parent_groups; end - def self.pending(*all_args, &block); end - def self.remove_example(example); end - def self.reset_memoized; end - def self.run(reporter = nil); end - def self.run_after_context_hooks(example_group_instance); end - def self.run_before_context_hooks(example_group_instance); end - def self.run_examples(reporter); end - def self.set_it_up(description, args, registration_collection, &example_group_block); end - def self.set_ivars(instance, ivars); end - def self.skip(*all_args, &block); end - def self.specify(*all_args, &block); end - def self.store_before_context_ivars(example_group_instance); end - def self.subclass(parent, description, args, registration_collection, &example_group_block); end - def self.superclass_before_context_ivars; end - def self.superclass_metadata; end - def self.top_level?; end - def self.top_level_description; end - def self.traverse_tree_until(&block); end - def self.update_inherited_metadata(updates); end - def self.with_replaced_metadata(meta); end - def self.xcontext(*args, &example_group_block); end - def self.xdescribe(*args, &example_group_block); end - def self.xexample(*all_args, &block); end - def self.xit(*all_args, &block); end - def self.xspecify(*all_args, &block); end - extend RSpec::Core::Hooks - extend RSpec::Core::MemoizedHelpers::ClassMethods - extend RSpec::Core::SharedExampleGroup - include RSpec::Core::MemoizedHelpers - include RSpec::Core::Pending -end -class RSpec::Core::ExampleGroup::WrongScopeError < NoMethodError -end -class RSpec::Core::AnonymousExampleGroup < RSpec::Core::ExampleGroup - def self.metadata; end -end -class RSpec::Core::SharedExampleGroupInclusionStackFrame - def description; end - def formatted_inclusion_location; end - def inclusion_location; end - def initialize(shared_group_name, inclusion_location); end - def self.current_backtrace; end - def self.shared_example_group_inclusions; end - def self.with_frame(name, location); end - def shared_group_name; end -end -module RSpec::ExampleGroups - def self.assign_const(group); end - def self.base_name_for(group); end - def self.constant_scope_for(group); end - def self.disambiguate(name, const_scope); end - def self.remove_all_constants; end - extend RSpec::Support::RecursiveConstMethods -end -module RSpec::Support - def self.require_rspec_core(f); end -end -class RSpec::Core::Time - def self.now(*arg0); end -end -class Module - def context(*a, &b); end - def describe(*a, &b); end - def example_group(*a, &b); end - def fcontext(*a, &b); end - def fdescribe(*a, &b); end - def shared_context(name, *args, &block); end - def shared_examples(name, *args, &block); end - def shared_examples_for(name, *args, &block); end - def xcontext(*a, &b); end - def xdescribe(*a, &b); end -end -module RSpec::Core::SharedContext - def __shared_context_recordings; end - def after(*args, &block); end - def append_after(*args, &block); end - def append_before(*args, &block); end - def around(*args, &block); end - def before(*args, &block); end - def context(*args, &block); end - def describe(*args, &block); end - def hooks(*args, &block); end - def included(group); end - def let!(*args, &block); end - def let(*args, &block); end - def prepend_after(*args, &block); end - def prepend_before(*args, &block); end - def self.record(methods); end - def subject!(*args, &block); end - def subject(*args, &block); end -end -class RSpec::Core::SharedContext::Recording < Struct - def args; end - def args=(_); end - def block; end - def block=(_); end - def method_name; end - def method_name=(_); end - def playback_onto(group); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::ExampleStatusPersister - def dump_statuses(unparsed_previous_runs); end - def initialize(examples, file_name); end - def persist; end - def self.load_from(file_name); end - def self.persist(examples, file_name); end - def statuses_from_this_run; end -end -class RSpec::Core::ExampleStatusMerger - def delete_previous_examples_that_no_longer_exist; end - def example_must_no_longer_exist?(ex_id); end - def hash_from(example_list); end - def initialize(this_run, from_previous_runs); end - def loaded_spec_files; end - def merge; end - def self.merge(this_run, from_previous_runs); end - def sort_value_from(example); end - def spec_file_from(ex_id); end -end -class RSpec::Core::ExampleStatusDumper - def column_widths; end - def dump; end - def formatted_header_rows; end - def formatted_row_from(row_values); end - def formatted_value_rows; end - def headers; end - def initialize(examples); end - def rows; end - def self.dump(examples); end -end -class RSpec::Core::ExampleStatusParser - def headers; end - def initialize(string); end - def parse; end - def parse_row(line); end - def self.parse(string); end - def split_line(line); end -end -class RSpec::Core::Profiler - def example_group_finished(notification); end - def example_group_started(notification); end - def example_groups; end - def example_started(notification); end - def initialize; end -end -class RSpec::Core::DidYouMean - def call; end - def formats(probables); end - def initialize(relative_file_name); end - def red_font(mytext); end - def relative_file_name; end - def top_and_tail(rspec_format); end -end -class RSpec::Core::Formatters::BaseFormatter - def close(_notification); end - def example_group; end - def example_group=(arg0); end - def example_group_started(notification); end - def initialize(output); end - def output; end - def output_supports_sync; end - def restore_sync_output; end - def start(notification); end - def start_sync_output; end -end -class RSpec::Core::Formatters::BaseTextFormatter < RSpec::Core::Formatters::BaseFormatter - def close(_notification); end - def dump_failures(notification); end - def dump_pending(notification); end - def dump_summary(summary); end - def message(notification); end - def seed(notification); end -end -class RSpec::Core::Formatters::DocumentationFormatter < RSpec::Core::Formatters::BaseTextFormatter - def current_indentation(offset = nil); end - def example_failed(failure); end - def example_group_finished(_notification); end - def example_group_started(notification); end - def example_passed(passed); end - def example_pending(pending); end - def example_started(_notification); end - def failure_output(example); end - def flush_messages; end - def initialize(output); end - def message(notification); end - def next_failure_index; end - def passed_output(example); end - def pending_output(example, message); end -end -class RSpec::Core::Formatters::HtmlPrinter - def flush; end - def indentation_style(number_of_parents); end - def initialize(output); end - def make_example_group_header_red(group_id); end - def make_example_group_header_yellow(group_id); end - def make_header_red; end - def make_header_yellow; end - def move_progress(percent_done); end - def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end - def print_example_group_end; end - def print_example_group_start(group_id, description, number_of_parents); end - def print_example_passed(description, run_time); end - def print_example_pending(description, pending_message); end - def print_html_start; end - def print_summary(duration, example_count, failure_count, pending_count); end - include ERB::Util -end -class RSpec::Core::Formatters::HtmlFormatter < RSpec::Core::Formatters::BaseFormatter - def dump_summary(summary); end - def example_failed(failure); end - def example_group_number; end - def example_group_started(notification); end - def example_number; end - def example_passed(passed); end - def example_pending(pending); end - def example_started(_notification); end - def extra_failure_content(failure); end - def initialize(output); end - def percent_done; end - def start(notification); end - def start_dump(_notification); end -end -class RSpec::Core::Formatters::FallbackMessageFormatter - def initialize(output); end - def message(notification); end - def output; end -end -class RSpec::Core::Formatters::ProgressFormatter < RSpec::Core::Formatters::BaseTextFormatter - def example_failed(_notification); end - def example_passed(_notification); end - def example_pending(_notification); end - def start_dump(_notification); end -end -class RSpec::Core::Formatters::ProfileFormatter - def bold(text); end - def dump_profile(profile); end - def dump_profile_slowest_example_groups(profile); end - def dump_profile_slowest_examples(profile); end - def format_caller(caller_info); end - def initialize(output); end - def output; end -end -class RSpec::Core::Formatters::JsonFormatter < RSpec::Core::Formatters::BaseFormatter - def close(_notification); end - def dump_profile(profile); end - def dump_profile_slowest_example_groups(profile); end - def dump_profile_slowest_examples(profile); end - def dump_summary(summary); end - def format_example(example); end - def initialize(output); end - def message(notification); end - def output_hash; end - def seed(notification); end - def stop(notification); end -end -module RSpec::Core::Bisect -end -class RSpec::Core::Bisect::ExampleSetDescriptor < Struct - def all_example_ids; end - def all_example_ids=(_); end - def failed_example_ids; end - def failed_example_ids=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Core::Bisect::BisectFailedError < StandardError - def self.for_failed_spec_run(spec_output); end -end -class RSpec::Core::Bisect::Notifier - def initialize(formatter); end - def publish(event, *args); end -end -class RSpec::Core::Bisect::Channel - def close; end - def initialize; end - def receive; end - def send(message); end -end -class RSpec::Core::Formatters::BaseBisectFormatter - def example_failed(notification); end - def example_finished(notification); end - def initialize(expected_failures); end - def self.inherited(formatter); end - def start_dump(_notification); end -end -class RSpec::Core::Formatters::BisectDRbFormatter < RSpec::Core::Formatters::BaseBisectFormatter - def initialize(_output); end - def notify_results(results); end -end -class RSpec::Core::Formatters::FailureListFormatter < RSpec::Core::Formatters::BaseFormatter - def dump_profile(_profile); end - def example_failed(failure); end - def message(_message); end -end diff --git a/sorbet/rbi/gems/rspec-core@3.11.0.rbi b/sorbet/rbi/gems/rspec-core@3.11.0.rbi new file mode 100644 index 00000000..96b0f9a8 --- /dev/null +++ b/sorbet/rbi/gems/rspec-core@3.11.0.rbi @@ -0,0 +1,10981 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rspec-core` gem. +# Please instead update this file by running `bin/tapioca gem rspec-core`. + +# Namespace for all core RSpec code. +# +# source://rspec-core-3.11.0/lib/rspec/core/version.rb:1 +module RSpec + extend ::RSpec::Core::Warnings + + class << self + # Used to ensure examples get reloaded between multiple runs in the same + # process and ensures user configuration is persisted. + # + # Users must invoke this if they want to clear all examples but preserve + # current configuration when they use the runner multiple times within the + # same process. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:70 + def clear_examples; end + + # Returns the global [Configuration](RSpec/Core/Configuration) object. While + # you _can_ use this method to access the configuration, the more common + # convention is to use [RSpec.configure](RSpec#configure-class_method). + # + # @example + # RSpec.configuration.drb_port = 1234 + # @see RSpec.configure + # @see Core::Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:85 + def configuration; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def configuration=(_arg0); end + + # Yields the global configuration to a block. + # + # @example + # RSpec.configure do |config| + # config.add_formatter 'documentation' + # end + # @see Core::Configuration + # @yield [Configuration] global configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:97 + def configure; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:194 + def const_missing(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def context(*args, &example_group_block); end + + # The example being executed. + # + # The primary audience for this method is library authors who need access + # to the example currently being executed and also want to support all + # versions of RSpec 2 and 3. + # + # @example + # + # RSpec.configure do |c| + # # context.example is deprecated, but RSpec.current_example is not + # # available until RSpec 3.0. + # fetch_current_example = RSpec.respond_to?(:current_example) ? + # proc { RSpec.current_example } : proc { |context| context.example } + # + # c.before(:example) do + # example = fetch_current_example.call(self) + # + # # ... + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:122 + def current_example; end + + # Set the current example being executed. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:128 + def current_example=(example); end + + # Get the current RSpec execution scope + # + # Returns (in order of lifecycle): + # * `:suite` as an initial value, this is outside of the test lifecycle. + # * `:before_suite_hook` during `before(:suite)` hooks. + # * `:before_context_hook` during `before(:context)` hooks. + # * `:before_example_hook` during `before(:example)` hooks and `around(:example)` before `example.run`. + # * `:example` within the example run. + # * `:after_example_hook` during `after(:example)` hooks and `around(:example)` after `example.run`. + # * `:after_context_hook` during `after(:context)` hooks. + # * `:after_suite_hook` during `after(:suite)` hooks. + # * `:suite` as a final value, again this is outside of the test lifecycle. + # + # Reminder, `:context` hooks have `:all` alias and `:example` hooks have `:each` alias. + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:154 + def current_scope; end + + # Set the current scope rspec is executing in + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:134 + def current_scope=(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def example_group(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fdescribe(*args, &example_group_block); end + + # Used to ensure examples get reloaded and user configuration gets reset to + # defaults between multiple runs in the same process. + # + # Users must invoke this if they want to have the configuration reset when + # they use the runner multiple times within the same process. Users must deal + # themselves with re-configuration of RSpec before run. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:58 + def reset; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_context(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples_for(name, *args, &block); end + + # Internal container for global non-configuration data. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:160 + def world; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def world=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xdescribe(*args, &example_group_block); end + end +end + +# Namespace for the rspec-core code. +# +# source://rspec-core-3.11.0/lib/rspec/core/version.rb:2 +module RSpec::Core + class << self + # @private path to executable file. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:181 + def path_to_executable; end + end +end + +# Unnamed example group used by `SuiteHookContext`. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:775 +class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:776 + def metadata; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:4 +class RSpec::Core::BacktraceFormatter + # @return [BacktraceFormatter] a new instance of BacktraceFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:8 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:49 + def backtrace_line(line); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:53 + def exclude?(line); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:6 + def exclusion_patterns; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:6 + def exclusion_patterns=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:28 + def filter_gem(gem_name); end + + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:33 + def format_backtrace(backtrace, options = T.unsafe(nil)); end + + # Sets the attribute full_backtrace + # + # @param value the value to set the attribute full_backtrace to. + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:22 + def full_backtrace=(_arg0); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:24 + def full_backtrace?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:6 + def inclusion_patterns; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:6 + def inclusion_patterns=(_arg0); end + + private + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/backtrace_formatter.rb:60 + def matches?(patterns, line); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:3 +module RSpec::Core::Bisect; end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:8 +class RSpec::Core::Bisect::BisectFailedError < ::StandardError + class << self + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:9 + def for_failed_spec_run(spec_output); end + end +end + +# Wraps a pipe to support sending objects between a child and +# parent process. Where supported, encoding is explicitly +# set to ensure binary data is able to pass from child to +# parent. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:36 +class RSpec::Core::Bisect::Channel + # @return [Channel] a new instance of Channel + # + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:41 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:62 + def close; end + + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:56 + def receive; end + + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:50 + def send(message); end +end + +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:38 +RSpec::Core::Bisect::Channel::MARSHAL_DUMP_ENCODING = T.let(T.unsafe(nil), Encoding) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:5 +class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct + # Returns the value of attribute all_example_ids + # + # @return [Object] the current value of all_example_ids + def all_example_ids; end + + # Sets the attribute all_example_ids + # + # @param value [Object] the value to set the attribute all_example_ids to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:5 + def all_example_ids=(_); end + + # Returns the value of attribute failed_example_ids + # + # @return [Object] the current value of failed_example_ids + def failed_example_ids; end + + # Sets the attribute failed_example_ids + # + # @param value [Object] the value to set the attribute failed_example_ids to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:5 + def failed_example_ids=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Wraps a `formatter` providing a simple means to notify it in place +# of an `RSpec::Core::Reporter`, without involving configuration in +# any way. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:19 +class RSpec::Core::Bisect::Notifier + # @return [Notifier] a new instance of Notifier + # + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:20 + def initialize(formatter); end + + # source://rspec-core-3.11.0/lib/rspec/core/bisect/utilities.rb:24 + def publish(event, *args); end +end + +# Stores runtime configuration information. +# +# Configuration options are loaded from multiple files and joined together +# with command-line switches and the `SPEC_OPTS` environment variable. +# +# Precedence order (where later entries overwrite earlier entries on +# conflicts): +# +# * Global (`$XDG_CONFIG_HOME/rspec/options`, or `~/.rspec` if it does +# not exist) +# * Project-specific (`./.rspec`) +# * Local (`./.rspec-local`) +# * Command-line options +# * `SPEC_OPTS` +# +# For example, an option set in the local file will override an option set +# in your global file. +# +# The global, project-specific and local files can all be overridden with a +# separate custom file using the --options command-line parameter. +# +# @example Standard settings +# RSpec.configure do |c| +# c.drb = true +# c.drb_port = 1234 +# c.default_path = 'behavior' +# end +# @example Hooks +# RSpec.configure do |c| +# c.before(:suite) { establish_connection } +# c.before(:example) { log_in_as :authorized } +# c.around(:example) { |ex| Database.transaction(&ex) } +# end +# @see RSpec.configure +# @see Hooks +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:47 +class RSpec::Core::Configuration + include ::RSpec::Core::Hooks + include ::RSpec::Core::Configuration::Readers + + # Build an object to store runtime configuration options and set defaults + # + # @return [Configuration] a new instance of Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:508 + def initialize; end + + # Adds a formatter to the set RSpec will use for this run. + # + # @overload add_formatter + # @overload add_formatter + # @param formatter [Class, String, Object] formatter to use. Can be any of the + # string values supported from the CLI (`p`/`progress`, + # `d`/`doc`/`documentation`, `h`/`html`, or `j`/`json`), any + # class that implements the formatter protocol and has registered + # itself with RSpec as a formatter, or a formatter instance. + # @param output [String, IO] where the formatter will write its output. + # Can be an IO object or a string path to a file. If not provided, + # the configured `output_stream` (`$stdout`, by default) will be used. + # @see RSpec::Core::Formatters::Protocol + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:973 + def add_formatter(formatter, output = T.unsafe(nil)); end + + # Adds a custom setting to the RSpec.configuration object. + # + # RSpec.configuration.add_setting :foo + # + # Used internally and by extension frameworks like rspec-rails, so they + # can add config settings that are domain specific. For example: + # + # RSpec.configure do |c| + # c.add_setting :use_transactional_fixtures, + # :default => true, + # :alias_with => :use_transactional_examples + # end + # + # `add_setting` creates three methods on the configuration object, a + # setter, a getter, and a predicate: + # + # RSpec.configuration.foo=(value) + # RSpec.configuration.foo + # RSpec.configuration.foo? # Returns true if foo returns anything but nil or false. + # + # @option opts + # @option opts + # @overload add_setting + # @overload add_setting + # @param opts [Hash] a customizable set of options + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:636 + def add_setting(name, opts = T.unsafe(nil)); end + + # Defines a `after` hook. See {Hooks#after} for full docs. + # + # This method differs from {Hooks#after} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once after + # the last example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #append_after + # @see #before + # @see #prepend_before + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2002 + def after(scope = T.unsafe(nil), *meta, &block); end + + # Creates a method that defines an example group with the provided + # metadata. Can be used to define example group/metadata shortcuts. + # + # @example + # RSpec.configure do |config| + # config.alias_example_group_to :describe_model, :type => :model + # end + # + # shared_context_for "model tests", :type => :model do + # # define common model test helper methods, `let` declarations, etc + # end + # + # # This lets you do this: + # + # RSpec.describe_model User do + # end + # + # # ... which is the equivalent of + # + # RSpec.describe User, :type => :model do + # end + # @note The defined aliased will also be added to the top level + # (e.g. `main` and from within modules) if + # `expose_dsl_globally` is set to true. + # @see #alias_example_to + # @see #expose_dsl_globally= + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1186 + def alias_example_group_to(new_name, *args); end + + # Creates a method that delegates to `example` including the submitted + # `args`. Used internally to add variants of `example` like `pending`: + # + # @example + # RSpec.configure do |config| + # config.alias_example_to :pending, :pending => true + # end + # + # # This lets you do this: + # + # RSpec.describe Thing do + # pending "does something" do + # thing = Thing.new + # end + # end + # + # # ... which is the equivalent of + # + # RSpec.describe Thing do + # it "does something", :pending => true do + # thing = Thing.new + # end + # end + # @note The specific example alias below (`pending`) is already + # defined for you. + # @note Use with caution. This extends the language used in your + # specs, but does not add any additional documentation. We use this + # in RSpec to define methods like `focus` and `xit`, but we also add + # docs for those methods. + # @param name [String] example name alias + # @param args [Array<Symbol>, Hash] metadata for the generated example + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1154 + def alias_example_to(name, *args); end + + # Define an alias for it_should_behave_like that allows different + # language (like "it_has_behavior" or "it_behaves_like") to be + # employed when including shared examples. + # + # @example + # RSpec.configure do |config| + # config.alias_it_behaves_like_to(:it_has_behavior, 'has behavior:') + # end + # + # # allows the user to include a shared example group like: + # + # RSpec.describe Entity do + # it_has_behavior 'sortability' do + # let(:sortable) { Entity.new } + # end + # end + # + # # which is reported in the output as: + # # Entity + # # has behavior: sortability + # # ...sortability examples here + # @note Use with caution. This extends the language used in your + # specs, but does not add any additional documentation. We use this + # in RSpec to define `it_should_behave_like` (for backward + # compatibility), but we also add docs for that method. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1217 + def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end + + # Define an alias for it_should_behave_like that allows different + # language (like "it_has_behavior" or "it_behaves_like") to be + # employed when including shared examples. + # + # @example + # RSpec.configure do |config| + # config.alias_it_behaves_like_to(:it_has_behavior, 'has behavior:') + # end + # + # # allows the user to include a shared example group like: + # + # RSpec.describe Entity do + # it_has_behavior 'sortability' do + # let(:sortable) { Entity.new } + # end + # end + # + # # which is reported in the output as: + # # Entity + # # has behavior: sortability + # # ...sortability examples here + # @note Use with caution. This extends the language used in your + # specs, but does not add any additional documentation. We use this + # in RSpec to define `it_should_behave_like` (for backward + # compatibility), but we also add docs for that method. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1217 + def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end + + # Adds `block` to the end of the list of `after` blocks in the same + # scope (`:example`, `:context`, or `:suite`), in contrast to {#after}, + # which adds the hook to the start of the list. + # + # See {Hooks#after} for full `after` hook docs. + # + # This method differs from {Hooks#append_after} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once after + # the last example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #append_after + # @see #before + # @see #prepend_before + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2032 + def append_after(scope = T.unsafe(nil), *meta, &block); end + + # Defines a `before` hook. See {Hooks#before} for full docs. + # + # This method differs from {Hooks#before} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once before + # the first example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #prepend_before + # @see #after + # @see #append_after + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1947 + def append_before(scope = T.unsafe(nil), *meta, &block); end + + # @private + # @raise [SystemStackError] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1912 + def apply_derived_metadata_to(metadata); end + + # Registers `block` as an `around` hook. + # + # See {Hooks#around} for full `around` hook docs. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2050 + def around(scope = T.unsafe(nil), *meta, &block); end + + # Regexps used to exclude lines from backtraces. + # + # Excludes lines from ruby (and jruby) source, installed gems, anything + # in any "bin" directory, and any of the RSpec libs (outside gem + # installs) by default. + # + # You can modify the list via the getter, or replace it with the setter. + # + # To override this behaviour and display a full backtrace, use + # `--backtrace` on the command line, in a `.rspec` file, or in the + # `rspec_options` attribute of RSpec's rake task. + # + # @return [Array<Regexp>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:674 + def backtrace_exclusion_patterns; end + + # Set regular expressions used to exclude lines in backtrace. + # + # @param patterns [Array<Regexp>] set backtrace_formatter exlusion_patterns + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:680 + def backtrace_exclusion_patterns=(patterns); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:503 + def backtrace_formatter; end + + # Regexps used to include lines in backtraces. + # + # Defaults to [Regexp.new Dir.getwd]. + # + # Lines that match an exclusion _and_ an inclusion pattern + # will be included. + # + # You can modify the list via the getter, or replace it with the setter. + # + # @return [Array<Regexp>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:693 + def backtrace_inclusion_patterns; end + + # Set regular expressions used to include lines in backtrace. + # + # @attr patterns [Array<Regexp>] set backtrace_formatter inclusion_patterns + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:699 + def backtrace_inclusion_patterns=(patterns); end + + # Defines a `before` hook. See {Hooks#before} for full docs. + # + # This method differs from {Hooks#before} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once before + # the first example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #prepend_before + # @see #after + # @see #append_after + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1947 + def before(scope = T.unsafe(nil), *meta, &block); end + + # Determines which bisect runner implementation gets used to run subsets + # of the suite during a bisection. Your choices are: + # + # - `:shell`: Performs a spec run by shelling out, booting RSpec and your + # application environment each time. This runner is the most widely + # compatible runner, but is not as fast. On platforms that do not + # support forking, this is the default. + # - `:fork`: Pre-boots RSpec and your application environment in a parent + # process, and then forks a child process for each spec run. This runner + # tends to be significantly faster than the `:shell` runner but cannot + # be used in some situations. On platforms that support forking, this + # is the default. If you use this runner, you should ensure that all + # of your one-time setup logic goes in a `before(:suite)` hook instead + # of getting run at the top-level of a file loaded by `--require`. + # + # @note This option will only be used by `--bisect` if you set it in a file + # loaded via `--require`. + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:480 + def bisect_runner; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:481 + def bisect_runner=(value); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2096 + def bisect_runner_class; end + + # Enables color output if the output is a TTY. As of RSpec 3.6, this is + # the default behavior and this option is retained only for backwards + # compatibility. + # + # @deprecated No longer recommended because of complex behavior. Instead, + # rely on the fact that TTYs will display color by default, or set + # {#color_mode} to :on to display color on a non-TTY output. + # @return [Boolean] + # @see color_mode + # @see color_enabled? + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:899 + def color; end + + # Toggle output color. + # + # @deprecated No longer recommended because of complex behavior. Instead, + # rely on the fact that TTYs will display color by default, or set + # {:color_mode} to :on to display color on a non-TTY output. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:937 + def color=(_arg0); end + + # Check if color is enabled for a particular output. + # + # @param output [IO] an output stream to use, defaults to the current + # `output_stream` + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:920 + def color_enabled?(output = T.unsafe(nil)); end + + # The mode for determining whether to display output in color. One of: + # + # - :automatic - the output will be in color if the output is a TTY (the + # default) + # - :on - the output will be in color, whether or not the output is a TTY + # - :off - the output will not be in color + # + # @return [Boolean] + # @see color_enabled? + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:912 + def color_mode; end + + # Set the color mode. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:930 + def color_mode=(_arg0); end + + # Used internally to extend the singleton class of a single example's + # example group instance with modules using `include` and/or `extend`. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1554 + def configure_example(example, example_hooks); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1594 + def configure_expectation_framework; end + + # Used internally to extend a group with modules using `include`, `prepend` and/or + # `extend`. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1542 + def configure_group(group); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1588 + def configure_mock_framework; end + + # The default output color. Defaults to `:white` but can be set to one of + # the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def default_color; end + + # The default output color. Defaults to `:white` but can be set to one of + # the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def default_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def default_color?; end + + # The formatter that will be used if no formatter has been set. + # Defaults to 'progress'. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:980 + def default_formatter; end + + # Sets a fallback formatter to use if none other has been set. + # + # @example + # + # RSpec.configure do |rspec| + # rspec.default_formatter = 'doc' + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:991 + def default_formatter=(value); end + + # Path to use if no path is provided to the `rspec` command (default: + # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to + # run all the examples in the `spec` directory. + # + # @note Other scripts invoking `rspec` indirectly will ignore this + # setting. + # @return [String] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def default_path; end + + # Path to use if no path is provided to the `rspec` command (default: + # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to + # run all the examples in the `spec` directory. + # + # @note Other scripts invoking `rspec` indirectly will ignore this + # setting. + # @return [String] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:121 + def default_path=(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def default_path?; end + + # Defines a callback that can assign derived metadata values. + # + # @example + # RSpec.configure do |config| + # # Tag all groups and examples in the spec/unit directory with + # # :type => :unit + # config.define_derived_metadata(:file_path => %r{/spec/unit/}) do |metadata| + # metadata[:type] = :unit + # end + # end + # @param filters [Array<Symbol>, Hash] metadata filters that determine + # which example or group metadata hashes the callback will be triggered + # for. If none are given, the callback will be run against the metadata + # hashes of all groups and examples. + # @yieldparam metadata [Hash] original metadata hash from an example or + # group. Mutate this in your block as needed. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1871 + def define_derived_metadata(*filters, &block); end + + # Determines where deprecation warnings are printed. + # Defaults to `$stderr`. + # + # @return [IO, String] IO or filename to write to + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def deprecation_stream; end + + # Determines where deprecation warnings are printed. + # + # @param value [IO, String] IO to write to or filename to write to + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:168 + def deprecation_stream=(value); end + + # Color used to print details. Defaults to `:cyan` but can be set to one + # of the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def detail_color; end + + # Color used to print details. Defaults to `:cyan` but can be set to one + # of the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def detail_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def detail_color?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1852 + def disable_monkey_patching; end + + # Enables zero monkey patching mode for RSpec. It removes monkey + # patching of the top-level DSL methods (`describe`, + # `shared_examples_for`, etc) onto `main` and `Module`, instead + # requiring you to prefix these methods with `RSpec.`. It enables + # expect-only syntax for rspec-mocks and rspec-expectations. It + # simply disables monkey patching on whatever pieces of RSpec + # the user is using. + # + # @example + # + # # It disables all monkey patching. + # RSpec.configure do |config| + # config.disable_monkey_patching! + # end + # + # # Is an equivalent to + # RSpec.configure do |config| + # config.expose_dsl_globally = false + # + # config.mock_with :rspec do |mocks| + # mocks.syntax = :expect + # mocks.patch_marshal_to_support_partial_doubles = false + # end + # + # config.expect_with :rspec do |expectations| + # expectations.syntax = :expect + # end + # end + # @note It configures rspec-mocks and rspec-expectations only + # if the user is using those (either explicitly or implicitly + # by not setting `mock_with` or `expect_with` to anything else). + # @note If the user uses this options with `mock_with :mocha` + # (or similiar) they will still have monkey patching active + # in their test environment from mocha. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1844 + def disable_monkey_patching!; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1852 + def disable_monkey_patching=(_arg0); end + + # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb + # server, but you can use tools like spork. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def drb; end + + # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb + # server, but you can use tools like spork. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def drb=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def drb?; end + + # The drb_port (default: nil). + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def drb_port; end + + # The drb_port (default: nil). + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def drb_port=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def drb_port?; end + + # Prints the formatter output of your suite without running any + # examples or hooks. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def dry_run; end + + # Prints the formatter output of your suite without running any + # examples or hooks. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def dry_run=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def dry_run?; end + + # The exit code to return if there are any errors outside examples (default: failure_exit_code) + # + # @return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def error_exit_code; end + + # The exit code to return if there are any errors outside examples (default: failure_exit_code) + # + # @return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def error_exit_code=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def error_exit_code?; end + + # Default: `$stderr`. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def error_stream; end + + # Default: `$stderr`. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def error_stream=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def error_stream?; end + + # The file path to use for persisting example statuses. Necessary for the + # `--only-failures` and `--next-failure` CLI options. + # + # @overload example_status_persistence_file_path + # @overload example_status_persistence_file_path= + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def example_status_persistence_file_path; end + + # Sets the file path to use for persisting example statuses. Necessary for the + # `--only-failures` and `--next-failure` CLI options. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:192 + def example_status_persistence_file_path=(value); end + + # Exclude files matching this pattern. + # + # @return [String] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def exclude_pattern; end + + # Set pattern to match files to exclude. + # + # @attr value [String] the filename pattern to exclude spec files by + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:304 + def exclude_pattern=(value); end + + # Returns the `exclusion_filter`. If none has been set, returns an empty + # hash. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1346 + def exclusion_filter; end + + # Clears and reassigns the `exclusion_filter`. Set to `nil` if you don't + # want any exclusion filter at all. + # + # ### Warning + # + # This overrides any exclusion filters/tags set on the command line or in + # configuration files. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1339 + def exclusion_filter=(filter); end + + # Sets the expectation framework module(s) to be included in each example + # group. + # + # `frameworks` can be `:rspec`, `:test_unit`, `:minitest`, a custom + # module, or any combination thereof: + # + # config.expect_with :rspec + # config.expect_with :test_unit + # config.expect_with :minitest + # config.expect_with :rspec, :minitest + # config.expect_with OtherExpectationFramework + # + # RSpec will translate `:rspec`, `:minitest`, and `:test_unit` into the + # appropriate modules. + # + # ## Configuration + # + # If the module responds to `configuration`, `expect_with` will + # yield the `configuration` object if given a block: + # + # config.expect_with OtherExpectationFramework do |custom_config| + # custom_config.custom_setting = true + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:835 + def expect_with(*frameworks); end + + # Delegates to expect_with(framework). + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:808 + def expectation_framework=(framework); end + + # Returns the configured expectation framework adapter module(s) + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:796 + def expectation_frameworks; end + + # Exposes the current running example via the named + # helper method. RSpec 2.x exposed this via `example`, + # but in RSpec 3.0, the example is instead exposed via + # an arg yielded to `it`, `before`, `let`, etc. However, + # some extension gems (such as Capybara) depend on the + # RSpec 2.x's `example` method, so this config option + # can be used to maintain compatibility. + # + # @example + # + # RSpec.configure do |rspec| + # rspec.expose_current_running_example_as :example + # end + # + # RSpec.describe MyClass do + # before do + # # `example` can be used here because of the above config. + # do_something if example.metadata[:type] == "foo" + # end + # end + # @param method_name [Symbol] the name of the helper method + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1782 + def expose_current_running_example_as(method_name); end + + # Use this to expose the core RSpec DSL via `Module` and the `main` + # object. It will be set automatically but you can override it to + # remove the DSL. + # Default: true + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:151 + def expose_dsl_globally=(value); end + + # Indicates if the DSL has been exposed off of modules and `main`. + # Default: true + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:143 + def expose_dsl_globally?; end + + # Tells RSpec to extend example groups with `mod`. Methods defined in + # `mod` are exposed to example groups (not examples). Use `filters` to + # constrain the groups to extend. + # + # Similar to `include`, but behavior is added to example groups, which + # are classes, rather than the examples, which are instances of those + # classes. + # + # @example + # + # module UiHelpers + # def run_in_browser + # # ... + # end + # end + # + # module PermissionHelpers + # def define_permissions + # # ... + # end + # end + # + # RSpec.configure do |config| + # config.extend(UiHelpers, :type => :request) + # config.extend(PermissionHelpers, :with_permissions, :type => :request) + # end + # + # describe "edit profile", :with_permissions, :type => :request do + # run_in_browser + # define_permissions + # + # it "does stuff in the client" do + # # ... + # end + # end + # @see #include + # @see #prepend + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1492 + def extend(mod, *filters); end + + # If specified, indicates the number of failures required before cleaning + # up and exit (default: `nil`). Can also be `true` to fail and exit on first + # failure + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def fail_fast; end + + # @see fail_fast + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:214 + def fail_fast=(value); end + + # Whether or not to fail when there are no RSpec examples (default: false). + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def fail_if_no_examples; end + + # Whether or not to fail when there are no RSpec examples (default: false). + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def fail_if_no_examples=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def fail_if_no_examples?; end + + # Color to use to indicate failure. Defaults to `:red` but can be set to + # one of the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def failure_color; end + + # Color to use to indicate failure. Defaults to `:red` but can be set to + # one of the following: `[:black, :white, :red, :green, :yellow, :blue, + # :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def failure_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def failure_color?; end + + # The exit code to return if there are any failures (default: 1). + # + # @return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def failure_exit_code; end + + # The exit code to return if there are any failures (default: 1). + # + # @return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def failure_exit_code=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def failure_exit_code?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1060 + def files_or_directories_to_run=(*files); end + + # The spec files RSpec will run. + # + # @return [Array] specified files about to run + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1073 + def files_to_run; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:497 + def files_to_run=(_arg0); end + + # Returns the `inclusion_filter`. If none has been set, returns an empty + # hash. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1290 + def filter; end + + # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't + # want any inclusion filter at all. + # + # ### Warning + # + # This overrides any inclusion filters/tags set on the command line or in + # configuration files. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1281 + def filter=(filter); end + + # Adds {#backtrace_exclusion_patterns} that will filter lines from + # the named gems from backtraces. + # + # @example + # RSpec.configure do |config| + # config.filter_gems_from_backtrace "rack", "rake" + # end + # @note The patterns this adds will match the named gems in their common + # locations (e.g. system gems, vendored with bundler, installed as a + # :git dependency with bundler, etc) but is not guaranteed to work for + # all possible gem locations. For example, if you have the gem source + # in a directory with a completely unrelated name, and use bundler's + # :path option, this will not filter it. + # @param gem_names [Array<String>] Names of the gems to filter + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:719 + def filter_gems_from_backtrace(*gem_names); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:499 + def filter_manager; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:499 + def filter_manager=(_arg0); end + + # Adds key/value pairs to the `inclusion_filter`. If `args` + # includes any symbols that are not part of the hash, each symbol + # is treated as a key in the hash with the value `true`. + # + # ### Note + # + # Filters set using this method can be overridden from the command line + # or config files (e.g. `.rspec`). + # + # @example + # # Given this declaration. + # describe "something", :foo => 'bar' do + # # ... + # end + # + # # Any of the following will include that group. + # config.filter_run_including :foo => 'bar' + # config.filter_run_including :foo => /^ba/ + # config.filter_run_including :foo => lambda {|v| v == 'bar'} + # config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # # Given a proc with an arity of 1, the lambda is passed the value + # # related to the key, e.g. + # config.filter_run_including :foo => lambda {|v| v == 'bar'} + # + # # Given a proc with an arity of 2, the lambda is passed the value + # # related to the key, and the metadata itself e.g. + # config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # filter_run_including :foo # same as filter_run_including :foo => true + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1252 + def filter_run(*args); end + + # Adds key/value pairs to the `exclusion_filter`. If `args` + # includes any symbols that are not part of the hash, each symbol + # is treated as a key in the hash with the value `true`. + # + # ### Note + # + # Filters set using this method can be overridden from the command line + # or config files (e.g. `.rspec`). + # + # @example + # # Given this declaration. + # describe "something", :foo => 'bar' do + # # ... + # end + # + # # Any of the following will exclude that group. + # config.filter_run_excluding :foo => 'bar' + # config.filter_run_excluding :foo => /^ba/ + # config.filter_run_excluding :foo => lambda {|v| v == 'bar'} + # config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # # Given a proc with an arity of 1, the lambda is passed the value + # # related to the key, e.g. + # config.filter_run_excluding :foo => lambda {|v| v == 'bar'} + # + # # Given a proc with an arity of 2, the lambda is passed the value + # # related to the key, and the metadata itself e.g. + # config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # filter_run_excluding :foo # same as filter_run_excluding :foo => true + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1326 + def filter_run_excluding(*args); end + + # Adds key/value pairs to the `inclusion_filter`. If `args` + # includes any symbols that are not part of the hash, each symbol + # is treated as a key in the hash with the value `true`. + # + # ### Note + # + # Filters set using this method can be overridden from the command line + # or config files (e.g. `.rspec`). + # + # @example + # # Given this declaration. + # describe "something", :foo => 'bar' do + # # ... + # end + # + # # Any of the following will include that group. + # config.filter_run_including :foo => 'bar' + # config.filter_run_including :foo => /^ba/ + # config.filter_run_including :foo => lambda {|v| v == 'bar'} + # config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # # Given a proc with an arity of 1, the lambda is passed the value + # # related to the key, e.g. + # config.filter_run_including :foo => lambda {|v| v == 'bar'} + # + # # Given a proc with an arity of 2, the lambda is passed the value + # # related to the key, and the metadata itself e.g. + # config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'} + # + # filter_run_including :foo # same as filter_run_including :foo => true + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1252 + def filter_run_including(*args); end + + # Applies the provided filter only if any of examples match, in constrast + # to {#filter_run}, which always applies even if no examples match, in + # which case no examples will be run. This allows you to leave configured + # filters in place that are intended only for temporary use. The most common + # example is focus filtering: `config.filter_run_when_matching :focus`. + # With that configured, you can temporarily focus an example or group + # by tagging it with `:focus` metadata, or prefixing it with an `f` + # (as in `fdescribe`, `fcontext` and `fit`) since those are aliases for + # `describe`/`context`/`it` with `:focus` metadata. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1268 + def filter_run_when_matching(*args); end + + # Color used when a pending example is fixed. Defaults to `:blue` but can + # be set to one of the following: `[:black, :white, :red, :green, + # :yellow, :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def fixed_color; end + + # Color used when a pending example is fixed. Defaults to `:blue` but can + # be set to one of the following: `[:black, :white, :red, :green, + # :yellow, :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def fixed_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def fixed_color?; end + + # Used to set higher priority option values from the command line. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:569 + def force(hash); end + + # Formats the docstring output using the block provided. + # + # @example + # # This will strip the descriptions of both examples and example + # # groups. + # RSpec.configure do |config| + # config.format_docstrings { |s| s.strip } + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1633 + def format_docstrings(&block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1638 + def format_docstrings_block; end + + # Adds a formatter to the set RSpec will use for this run. + # + # @overload add_formatter + # @overload add_formatter + # @param formatter [Class, String, Object] formatter to use. Can be any of the + # string values supported from the CLI (`p`/`progress`, + # `d`/`doc`/`documentation`, `h`/`html`, or `j`/`json`), any + # class that implements the formatter protocol and has registered + # itself with RSpec as a formatter, or a formatter instance. + # @param output [String, IO] where the formatter will write its output. + # Can be an IO object or a string path to a file. If not provided, + # the configured `output_stream` (`$stdout`, by default) will be used. + # @see RSpec::Core::Formatters::Protocol + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:973 + def formatter=(formatter, output = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1006 + def formatter_loader; end + + # Returns a duplicate of the formatters currently loaded in + # the `FormatterLoader` for introspection. + # + # Note as this is a duplicate, any mutations will be disregarded. + # + # @return [Array] the formatters currently loaded + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1001 + def formatters; end + + # Toggle full backtrace. + # + # @attr true_or_false [Boolean] toggle full backtrace display + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:885 + def full_backtrace=(true_or_false); end + + # Check if full backtrace is enabled. + # + # @return [Boolean] is full backtrace enabled + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:879 + def full_backtrace?; end + + # @return [Array] full description filter + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:954 + def full_description; end + + # Run examples matching on `description` in all files to run. + # + # @param description [String, Regexp] the pattern to filter on + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:949 + def full_description=(description); end + + # Holds the various registered hooks. Here we use a FilterableItemRepository + # implementation that is specifically optimized for the read/write patterns + # of the config object. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2080 + def hooks; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1579 + def in_project_source_dir_regex; end + + # Tells RSpec to include `mod` in example groups. Methods defined in + # `mod` are exposed to examples (not example groups). Use `filters` to + # constrain the groups or examples in which to include the module. + # + # @example + # + # module AuthenticationHelpers + # def login_as(user) + # # ... + # end + # end + # + # module PreferencesHelpers + # def preferences(user, preferences = {}) + # # ... + # end + # end + # + # module UserHelpers + # def users(username) + # # ... + # end + # end + # + # RSpec.configure do |config| + # config.include(UserHelpers) # included in all groups + # + # # included in examples with `:preferences` metadata + # config.include(PreferenceHelpers, :preferences) + # + # # included in examples with `:type => :request` metadata + # config.include(AuthenticationHelpers, :type => :request) + # end + # + # describe "edit profile", :preferences, :type => :request do + # it "can be viewed by owning user" do + # login_as preferences(users(:jdoe), :lang => 'es') + # get "/profiles/jdoe" + # assert_select ".username", :text => 'jdoe' + # end + # end + # @note Filtered module inclusions can also be applied to + # individual examples that have matching metadata. Just like + # Ruby's object model is that every object has a singleton class + # which has only a single instance, RSpec's model is that every + # example has a singleton example group containing just the one + # example. + # @see #include_context + # @see #extend + # @see #prepend + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1402 + def include(mod, *filters); end + + # Tells RSpec to include the named shared example group in example groups. + # Use `filters` to constrain the groups or examples in which to include + # the example group. + # + # @example + # + # RSpec.shared_context "example admin user" do + # let(:admin_user) { create_user(:admin) } + # end + # + # RSpec.shared_context "example guest user" do + # let(:guest_user) { create_user(:guest) } + # end + # + # RSpec.configure do |config| + # config.include_context "example guest user", :type => :request + # config.include_context "example admin user", :admin, :type => :request + # end + # + # RSpec.describe "The admin page", :type => :request do + # it "can be viewed by admins", :admin do + # login_with admin_user + # get "/admin" + # expect(response).to be_ok + # end + # + # it "cannot be viewed by guests" do + # login_with guest_user + # get "/admin" + # expect(response).to be_forbidden + # end + # end + # @note Filtered context inclusions can also be applied to + # individual examples that have matching metadata. Just like + # Ruby's object model is that every object has a singleton class + # which has only a single instance, RSpec's model is that every + # example has a singleton example group containing just the one + # example. + # @see #include + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1449 + def include_context(shared_group_name, *filters); end + + # Returns the `inclusion_filter`. If none has been set, returns an empty + # hash. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1290 + def inclusion_filter; end + + # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't + # want any inclusion filter at all. + # + # ### Warning + # + # This overrides any inclusion filters/tags set on the command line or in + # configuration files. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1281 + def inclusion_filter=(filter); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1078 + def last_run_statuses; end + + # Returns dirs that have been prepended to the load path by the `-I` + # command line option. + # + # @return [Array<String>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def libs; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:940 + def libs=(libs); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1602 + def load_spec_files; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:503 + def loaded_spec_files; end + + # Maximum count of failed source lines to display in the failure reports. + # (default `10`). + # return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def max_displayed_failure_line_count; end + + # Maximum count of failed source lines to display in the failure reports. + # (default `10`). + # return [Integer] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def max_displayed_failure_line_count=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def max_displayed_failure_line_count?; end + + # Returns the configured mock framework adapter module. + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:646 + def mock_framework; end + + # Delegates to mock_framework=(framework). + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:658 + def mock_framework=(framework); end + + # Sets the mock framework adapter module. + # + # `framework` can be a Symbol or a Module. + # + # Given any of `:rspec`, `:mocha`, `:flexmock`, or `:rr`, configures the + # named framework. + # + # Given `:nothing`, configures no framework. Use this if you don't use + # any mocking framework to save a little bit of overhead. + # + # Given a Module, includes that module in every example group. The module + # should adhere to RSpec's mock framework adapter API: + # + # setup_mocks_for_rspec + # - called before each example + # + # verify_mocks_for_rspec + # - called after each example if the example hasn't yet failed. + # Framework should raise an exception when expectations fail + # + # teardown_mocks_for_rspec + # - called after verify_mocks_for_rspec (even if there are errors) + # + # If the module responds to `configuration` and `mock_with` receives a + # block, it will yield the configuration object to the block e.g. + # + # config.mock_with OtherMockFrameworkAdapter do |mod_config| + # mod_config.custom_setting = true + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:763 + def mock_with(framework); end + + # Invokes block before defining an example group + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2085 + def on_example_group_definition(&block); end + + # Returns an array of blocks to call before defining an example group + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2091 + def on_example_group_definition_callbacks; end + + # Indicates if the `--only-failures` (or `--next-failure`) flag is being used. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def only_failures; end + + # Indicates if the `--only-failures` (or `--next-failure`) flag is being used. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def only_failures?; end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:203 + def only_failures_but_not_configured?; end + + # Sets the default global ordering strategy. By default this can be one + # of `:defined`, `:random`, but is customizable through the + # `register_ordering` API. If order is set to `'rand:<seed>'`, + # the seed will also be set. + # + # @see #register_ordering + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def order=(*args, &block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:503 + def ordering_manager; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def ordering_registry(*args, &block); end + + # Determines where RSpec will send its output. + # Default: `$stdout`. + # + # @return [IO, String] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def output_stream; end + + # Set the output stream for reporter. + # + # @attr value [IO, String] IO to write to or filename to write to, defaults to $stdout + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:274 + def output_stream=(value); end + + # Load files matching this pattern (default: `'**{,/*/**}/*_spec.rb'`). + # + # @return [String] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def pattern; end + + # Set pattern to match files to load. + # + # @attr value [String] the filename pattern to filter spec files by + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:293 + def pattern=(value); end + + # Color to use to print pending examples. Defaults to `:yellow` but can + # be set to one of the following: `[:black, :white, :red, :green, + # :yellow, :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def pending_color; end + + # Color to use to print pending examples. Defaults to `:yellow` but can + # be set to one of the following: `[:black, :white, :red, :green, + # :yellow, :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def pending_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def pending_color?; end + + # Tells RSpec to prepend example groups with `mod`. Methods defined in + # `mod` are exposed to examples (not example groups). Use `filters` to + # constrain the groups in which to prepend the module. + # + # Similar to `include`, but module is included before the example group's class + # in the ancestor chain. + # + # @example + # + # module OverrideMod + # def override_me + # "overridden" + # end + # end + # + # RSpec.configure do |config| + # config.prepend(OverrideMod, :method => :prepend) + # end + # + # describe "overriding example's class", :method => :prepend do + # it "finds the user" do + # self.class.class_eval do + # def override_me + # end + # end + # override_me # => "overridden" + # # ... + # end + # end + # @see #include + # @see #extend + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1531 + def prepend(mod, *filters); end + + # Defines a `after` hook. See {Hooks#after} for full docs. + # + # This method differs from {Hooks#after} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once after + # the last example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #append_after + # @see #before + # @see #prepend_before + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2002 + def prepend_after(scope = T.unsafe(nil), *meta, &block); end + + # Adds `block` to the start of the list of `before` blocks in the same + # scope (`:example`, `:context`, or `:suite`), in contrast to {#before}, + # which adds the hook to the end of the list. + # + # See {Hooks#before} for full `before` hook docs. + # + # This method differs from {Hooks#prepend_before} in only one way: it supports + # the `:suite` scope. Hooks with the `:suite` scope will be run once before + # the first example of the entire suite is executed. Conditions passed along + # with `:suite` are effectively ignored. + # + # @see #before + # @see #after + # @see #append_after + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1977 + def prepend_before(scope = T.unsafe(nil), *meta, &block); end + + # Defaults `profile_examples` to 10 examples when `@profile_examples` is + # `true`. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1050 + def profile_examples; end + + # Report the times for the slowest examples (default: `false`). + # Use this to specify the number of examples to include in the profile. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:322 + def profile_examples=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def profile_examples?; end + + # Specifies which directories contain the source code for your project. + # When a failure occurs, RSpec looks through the backtrace to find a + # a line of source to print. It first looks for a line coming from + # one of the project source directories so that, for example, it prints + # the expectation or assertion call rather than the source code from + # the expectation or assertion framework. + # + # @return [Array<String>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def project_source_dirs; end + + # Specifies which directories contain the source code for your project. + # When a failure occurs, RSpec looks through the backtrace to find a + # a line of source to print. It first looks for a line coming from + # one of the project source directories so that, for example, it prints + # the expectation or assertion call rather than the source code from + # the expectation or assertion framework. + # + # @return [Array<String>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def project_source_dirs=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def project_source_dirs?; end + + # Turns deprecation warnings into errors, in order to surface + # the full backtrace of the call site. This can be useful when + # you need more context to address a deprecation than the + # single-line call site normally provided. + # + # @example + # + # RSpec.configure do |rspec| + # rspec.raise_errors_for_deprecations! + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1804 + def raise_errors_for_deprecations!; end + + # Turns warnings into errors. This can be useful when + # you want RSpec to run in a 'strict' no warning situation. + # + # @example + # + # RSpec.configure do |rspec| + # rspec.raise_on_warning = true + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1752 + def raise_on_warning=(value); end + + # Registers a named ordering strategy that can later be + # used to order an example group's subgroups by adding + # `:order => <name>` metadata to the example group. + # + # @example + # RSpec.configure do |rspec| + # rspec.register_ordering :reverse do |list| + # list.reverse + # end + # end + # + # RSpec.describe 'MyClass', :order => :reverse do + # # ... + # end + # @example + # RSpec.configure do |rspec| + # rspec.register_ordering :global do |examples| + # acceptance, other = examples.partition do |example| + # example.metadata[:type] == :acceptance + # end + # other + acceptance + # end + # end + # + # RSpec.describe 'MyClass', :type => :acceptance do + # # will run last + # end + # + # RSpec.describe 'MyClass' do + # # will run first + # end + # @note Pass the symbol `:global` to set the ordering strategy that + # will be used to order the top-level example groups and any example + # groups that do not have declared `:order` metadata. + # @param name [Symbol] The name of the ordering. + # @yield Block that will order the given examples or example groups + # @yieldparam list [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The examples or groups to order + # @yieldreturn [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The re-ordered examples or groups + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def register_ordering(*args, &block); end + + # @return [RSpec::Core::Reporter] the currently configured reporter + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1033 + def reporter; end + + # Indicates files configured to be required. + # + # @return [Array<String>] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def requires; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1571 + def requires=(paths); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:578 + def reset; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:591 + def reset_filters; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:584 + def reset_reporter; end + + # Run all examples if none match the configured filters + # (default: `false`). + # + # @deprecated Use {#filter_run_when_matching} instead for the specific + # filters that you want to be ignored if none match. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def run_all_when_everything_filtered; end + + # Run all examples if none match the configured filters + # (default: `false`). + # + # @deprecated Use {#filter_run_when_matching} instead for the specific + # filters that you want to be ignored if none match. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def run_all_when_everything_filtered=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def run_all_when_everything_filtered?; end + + # Seed for random ordering (default: generated randomly each run). + # + # When you run specs with `--order random`, RSpec generates a random seed + # for the randomization and prints it to the `output_stream` (assuming + # you're using RSpec's built-in formatters). If you discover an ordering + # dependency (i.e. examples fail intermittently depending on order), set + # this (on Configuration or on the command line with `--seed`) to run + # using the same seed while you debug the issue. + # + # We recommend, actually, that you use the command line approach so you + # don't accidentally leave the seed encoded. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def seed(*args, &block); end + + # Sets the seed value and sets the default global ordering to random. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def seed=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1645 + def seed_used?(*args, &block); end + + # Configures how RSpec treats metadata passed as part of a shared example + # group definition. For example, given this shared example group definition: + # + # RSpec.shared_context "uses DB", :db => true do + # around(:example) do |ex| + # MyORM.transaction(:rollback => true, &ex) + # end + # end + # + # ...there are two ways RSpec can treat the `:db => true` metadata, each + # of which has a corresponding config option: + # + # 1. `:trigger_inclusion`: this shared context will be implicitly included + # in any groups (or examples) that have `:db => true` metadata. + # 2. `:apply_to_host_groups`: the metadata will be inherited by the metadata + # hash of all host groups and examples. + # + # `:trigger_inclusion` is the legacy behavior from before RSpec 3.5 but should + # be considered deprecated. Instead, you can explicitly include a group with + # `include_context`: + # + # RSpec.describe "My model" do + # include_context "uses DB" + # end + # + # ...or you can configure RSpec to include the context based on matching metadata + # using an API that mirrors configured module inclusion: + # + # RSpec.configure do |rspec| + # rspec.include_context "uses DB", :db => true + # end + # + # `:apply_to_host_groups` is a new feature of RSpec 3.5 and will be the only + # supported behavior in RSpec 4. + # + # @overload shared_context_metadata_behavior + # @overload shared_context_metadata_behavior= + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def shared_context_metadata_behavior; end + + # @see shared_context_metadata_behavior + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:434 + def shared_context_metadata_behavior=(value); end + + # Don't print filter info i.e. "Run options: include {:focus=>true}" + # (default `false`). + # return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def silence_filter_announcements; end + + # Don't print filter info i.e. "Run options: include {:focus=>true}" + # (default `false`). + # return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def silence_filter_announcements=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def silence_filter_announcements?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1115 + def spec_files_with_failures; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def start_time; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def start_time=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def start_time?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:501 + def static_config_filter_manager; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:501 + def static_config_filter_manager=(_arg0); end + + # Color to use to indicate success. Defaults to `:green` but can be set + # to one of the following: `[:black, :white, :red, :green, :yellow, + # :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def success_color; end + + # Color to use to indicate success. Defaults to `:green` but can be set + # to one of the following: `[:black, :white, :red, :green, :yellow, + # :blue, :magenta, :cyan]` + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def success_color=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def success_color?; end + + # Use threadsafe options where available. + # Currently this will place a mutex around memoized values such as let blocks. + # return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def threadsafe; end + + # Use threadsafe options where available. + # Currently this will place a mutex around memoized values such as let blocks. + # return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def threadsafe=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def threadsafe?; end + + # @deprecated This config option was added in RSpec 2 to pave the way + # for this being the default behavior in RSpec 3. Now this option is + # a no-op. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:383 + def treat_symbols_as_metadata_keys_with_true_values=(_value); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:66 + def tty; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:89 + def tty=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:78 + def tty?; end + + # Set Ruby warnings on or off. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1732 + def warnings=(value); end + + # @return [Boolean] Whether or not ruby warnings are enabled. + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1737 + def warnings?; end + + # Defines a callback that runs after the first example with matching + # metadata is defined. If no examples are defined with matching metadata, + # it will not get called at all. + # + # This can be used to ensure some setup is performed (such as bootstrapping + # a DB or loading a specific file that adds significantly to the boot time) + # if needed (as indicated by the presence of an example with matching metadata) + # but avoided otherwise. + # + # @example + # RSpec.configure do |config| + # config.when_first_matching_example_defined(:db) do + # # Load a support file that does some heavyweight setup, + # # including bootstrapping the DB, but only if we have loaded + # # any examples tagged with `:db`. + # require 'support/db' + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1894 + def when_first_matching_example_defined(*filters); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2062 + def with_suite_hooks; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:499 + def world; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:499 + def world=(_arg0); end + + private + + # :nocov: + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2218 + def absolute_pattern?(pattern); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2319 + def add_hook_to_existing_matching_groups(meta, scope, &block); end + + # @raise [MustBeConfiguredBeforeExampleGroupsError] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2258 + def assert_no_example_groups_defined(config_option); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2308 + def clear_values_derived_from_example_status_persistence_file_path; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2240 + def command; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2284 + def conditionally_disable_expectations_monkey_patching; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2275 + def conditionally_disable_mocks_monkey_patching; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2313 + def configure_group_with(group, module_list, application_method); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2248 + def define_built_in_hooks; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2371 + def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2223 + def extract_location(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2200 + def file_glob_from(path, pattern); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2189 + def gather_directories(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2168 + def get_files_to_run(paths); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2195 + def get_matching_files(path, pattern); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2135 + def handle_suite_hook(scope, meta); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2114 + def load_file_handling_errors(method, file); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2341 + def metadata_applies_to_group?(meta, group); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2333 + def on_existing_matching_groups(meta); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2271 + def output_to_tty?(output = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2267 + def output_wrapper; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2180 + def paths_to_check(paths); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2185 + def pattern_might_load_specs_from_vendored_dirs?; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2294 + def rspec_expectations_loaded?; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2290 + def rspec_mocks_loaded?; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2150 + def run_suite_hooks(hook_description, hooks); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2356 + def safe_extend(mod, host); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2352 + def safe_include(mod, host); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2346 + def safe_prepend(mod, host); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2298 + def update_pattern_attr(name, value); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:2244 + def value_for(key); end + + class << self + # As `add_setting` but only add the reader. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:100 + def add_read_only_setting(name, opts = T.unsafe(nil)); end + + # Invoked by the `add_setting` instance method. Use that method on a + # `Configuration` instance rather than this class method. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:87 + def add_setting(name, opts = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:70 + def define_alias(name, alias_name); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:77 + def define_predicate(name); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:60 + def define_reader(name); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1643 + def delegate_to_ordering_manager(*methods); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1623 +RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc) + +# This buffer is used to capture all messages sent to the reporter during +# reporter initialization. It can then replay those messages after the +# formatter is correctly initialized. Otherwise, deprecation warnings +# during formatter initialization can cause an infinite loop. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1016 +class RSpec::Core::Configuration::DeprecationReporterBuffer + # @return [DeprecationReporterBuffer] a new instance of DeprecationReporterBuffer + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1017 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1021 + def deprecation(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1025 + def play_onto(reporter); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1792 +module RSpec::Core::Configuration::ExposeCurrentExample; end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1103 +RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:726 +RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:57 +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError; end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1106 +RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1109 +RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1742 +RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc) + +# Module that holds `attr_reader` declarations. It's in a separate +# module to allow us to override those methods and use `super`. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:53 +module RSpec::Core::Configuration::Readers + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def default_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def default_path; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def deprecation_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def detail_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def drb; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def drb_port; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def dry_run; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def error_exit_code; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def error_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def example_status_persistence_file_path; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def exclude_pattern; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def fail_fast; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def fail_if_no_examples; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def failure_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def failure_exit_code; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def fixed_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def libs; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def max_displayed_failure_line_count; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def only_failures; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def output_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def pattern; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def pending_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def project_source_dirs; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def requires; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def run_all_when_everything_filtered; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def shared_context_metadata_behavior; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def silence_filter_announcements; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def start_time; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def success_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def threadsafe; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:63 + def tty; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1100 +RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration.rb:1112 +RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array) + +# Responsible for utilizing externally provided configuration options, +# whether via the command line, `.rspec`, `~/.rspec`, +# `$XDG_CONFIG_HOME/rspec/options`, `.rspec-local` or a custom options +# file. +# +# source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:10 +class RSpec::Core::ConfigurationOptions + # @param args [Array<String>] command line arguments + # @return [ConfigurationOptions] a new instance of ConfigurationOptions + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:12 + def initialize(args); end + + # @return [Array<String>] the original command-line arguments + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:40 + def args; end + + # Updates the provided {Configuration} instance based on the provided + # external configuration options. + # + # @param config [Configuration] the configuration instance to update + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:21 + def configure(config); end + + # Updates the provided {FilterManager} based on the filter options. + # + # @api private + # @param filter_manager [FilterManager] instance to update + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:30 + def configure_filter_manager(filter_manager); end + + # @return [Hash] the final merged options, drawn from all external sources + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:37 + def options; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:169 + def args_from_options_file(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:138 + def command_line_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:142 + def custom_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:183 + def custom_options_file; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:129 + def env_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:121 + def file_options; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:66 + def force?(key); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:154 + def global_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:195 + def global_options_file; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:206 + def home_options_file_path; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:117 + def load_formatters_into(config); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:146 + def local_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:191 + def local_options_file; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:175 + def options_file_as_erb_string(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:158 + def options_from(path); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:70 + def order(keys); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:44 + def organize_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:163 + def parse_args_ignoring_files_or_dirs_to_run(args, source); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:109 + def process_options_into(config); end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:150 + def project_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:187 + def project_options_file; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:222 + def resolve_xdg_config_home; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:199 + def xdg_options_file_if_exists; end + + # source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:215 + def xdg_options_file_path; end +end + +# source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:77 +RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array) + +# source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:59 +RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +# source://rspec-core-3.11.0/lib/rspec/core/configuration_options.rb:64 +RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +# DSL defines methods to group examples, most notably `describe`, +# and exposes them as class methods of {RSpec}. They can also be +# exposed globally (on `main` and instances of `Module`) through +# the {Configuration} option `expose_dsl_globally`. +# +# By default the methods `describe`, `context` and `example_group` +# are exposed. These methods define a named context for one or +# more examples. The given block is evaluated in the context of +# a generated subclass of {RSpec::Core::ExampleGroup}. +# +# ## Examples: +# +# RSpec.describe "something" do +# context "when something is a certain way" do +# it "does something" do +# # example code goes here +# end +# end +# end +# +# @see ExampleGroup +# @see ExampleGroup.example_group +# +# source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:25 +module RSpec::Core::DSL + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:89 + def change_global_dsl(&changes); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:27 + def example_group_aliases; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:37 + def expose_example_group_alias(name); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:81 + def expose_example_group_alias_globally(method_name); end + + # Adds the describe method to Module and the top level binding. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:58 + def expose_globally!; end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:32 + def exposed_globally?; end + + # Removes the describe method from Module and the top level binding. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:70 + def remove_globally!; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:53 + def top_level; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:53 + def top_level=(_arg0); end + end +end + +# Deprecation Error. +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:221 +class RSpec::Core::DeprecationError < ::StandardError; end + +# Wrapper around Ruby's `DidYouMean::SpellChecker` when available to provide file name suggestions. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:5 +class RSpec::Core::DidYouMean + # @return [DidYouMean] a new instance of DidYouMean + # + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:8 + def initialize(relative_file_name); end + + # return a hint if API for ::DidYouMean::SpellChecker not supported + # + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:14 + def call; end + + # Returns the value of attribute relative_file_name. + # + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:6 + def relative_file_name; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:30 + def formats(probables); end + + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:40 + def red_font(mytext); end + + # source://rspec-core-3.11.0/lib/rspec/core/did_you_mean.rb:35 + def top_and_tail(rspec_format); end +end + +# Wrapper for an instance of a subclass of {ExampleGroup}. An instance of +# `RSpec::Core::Example` is returned by example definition methods +# such as {ExampleGroup.it it} and is yielded to the {ExampleGroup.it it}, +# {Hooks#before before}, {Hooks#after after}, {Hooks#around around}, +# {MemoizedHelpers::ClassMethods#let let} and +# {MemoizedHelpers::ClassMethods#subject subject} blocks. +# +# This allows us to provide rich metadata about each individual +# example without adding tons of methods directly to the ExampleGroup +# that users may inadvertently redefine. +# +# Useful for configuring logging and/or taking some action based +# on the state of an example's metadata. +# +# @example +# +# RSpec.configure do |config| +# config.before do |example| +# log example.description +# end +# +# config.after do |example| +# log example.description +# end +# +# config.around do |example| +# log example.description +# example.run +# end +# end +# +# shared_examples "auditable" do +# it "does something" do +# log "#{example.full_description}: #{auditable.inspect}" +# auditable.should do_something +# end +# end +# @note Example blocks are evaluated in the context of an instance +# of an `ExampleGroup`, not in the context of an instance of `Example`. +# @see ExampleGroup +# +# source://rspec-core-3.11.0/lib/rspec/core/example.rb:44 +class RSpec::Core::Example + # Creates a new instance of Example. + # + # @api private + # @param example_group_class [Class] the subclass of ExampleGroup in which + # this Example is declared + # @param description [String] the String passed to the `it` method (or + # alias) + # @param user_metadata [Hash] additional args passed to `it` to be used as + # metadata + # @param example_block [Proc] the block of code that represents the + # example + # @return [Example] a new instance of Example + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:186 + def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end + + # @attr + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:174 + def clock; end + + # @attr + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:174 + def clock=(_arg0); end + + # Returns the string submitted to `example` or its aliases (e.g. + # `specify`, `it`, etc). If no string is submitted (e.g. + # `it { is_expected.to do_something }`) it returns the message generated + # by the matcher if there is one, otherwise returns a message including + # the location of the example. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:76 + def description; end + + # The exception that will be displayed to the user -- either the failure of + # the example or the `pending_exception` if the example is pending. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:388 + def display_exception; end + + # Assigns the exception that will be displayed to the user -- either the failure of + # the example or the `pending_exception` if the example is pending. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:396 + def display_exception=(ex); end + + # Duplicates the example and overrides metadata with the provided + # hash. + # + # @param metadata_overrides [Hash] the hash to override the example metadata + # @return [Example] a duplicate of the example with modified metadata + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:132 + def duplicate_with(metadata_overrides = T.unsafe(nil)); end + + # Returns the example group class that provides the context for running + # this example. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:230 + def example_group; end + + # Returns the example_group_instance that provides the context for + # running this example. + # + # @attr_reader + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:170 + def example_group_instance; end + + # Returns the first exception raised in the context of running this + # example (nil if no exception is raised). + # + # @attr_reader + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:158 + def exception; end + + # @return [ExecutionResult] represents the result of running this example. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def execution_result; end + + # Used internally to set an exception and fail without actually executing + # the example when an exception is raised in before(:context). + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:439 + def fail_with_exception(reporter, exception); end + + # @return [String] the relative path to the file where this example was + # defined. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def file_path; end + + # @return [String] the full description (including the docstrings of + # all parent example groups). + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def full_description; end + + # @return [String] the unique id of this example. Pass + # this at the command line to re-run this exact example. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:117 + def id; end + + # Provide a human-readable representation of this class + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:220 + def inspect; end + + # Returns a description of the example that always includes the location. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:87 + def inspect_output; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:456 + def instance_exec(*args, &block); end + + # @return [String] the exact source location of this example in a form + # like `./path/to/spec.rb:17` + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def location; end + + # Returns the location-based argument that can be passed to the `rspec` command to rerun this example. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:96 + def location_rerun_argument; end + + # Returns the metadata object associated with this example. + # + # @attr_reader + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:163 + def metadata; end + + # @return [Boolean] flag that indicates that the example is not expected + # to pass. It will be run and will either have a pending result (if a + # failure occurs) or a failed result (if no failure occurs). + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def pending; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:234 + def pending?; end + + # @return [RSpec::Core::Reporter] the current reporter for the example + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:226 + def reporter; end + + # Returns the location-based argument that can be passed to the `rspec` command to rerun this example. + # + # @deprecated Use {#location_rerun_argument} instead. + # @note If there are multiple examples identified by this location, they will use {#id} + # to rerun instead, but this method will still return the location (that's why it is deprecated!). + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:111 + def rerun_argument; end + + # instance_execs the block passed to the constructor in the context of + # the instance of {ExampleGroup}. + # + # @api private + # @param example_group_instance the instance of an ExampleGroup subclass + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:246 + def run(example_group_instance, reporter); end + + # Used to set the exception when `aggregate_failures` fails. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:425 + def set_aggregate_failures_exception(exception); end + + # Used internally to set an exception in an after hook, which + # captures the exception but doesn't raise it. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:412 + def set_exception(exception); end + + # @return [Boolean] flag that will cause the example to not run. + # The {ExecutionResult} status will be `:pending`. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:49 + def skip; end + + # Used internally to skip without actually executing the example when + # skip is used in before(:context). + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:449 + def skip_with_exception(reporter, exception); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:238 + def skipped?; end + + # Provide a human-readable representation of this class + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:220 + def to_s; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:148 + def update_inherited_metadata(updates); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:534 + def assign_generated_description; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:478 + def finish(reporter); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:543 + def generate_description; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:462 + def hooks; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:550 + def location_description; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:530 + def mocks_need_verification?; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:498 + def record_finished(status, reporter); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:516 + def run_after_example; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:503 + def run_before_example; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:473 + def start(reporter); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:524 + def verify_mocks; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:508 + def with_around_and_singleton_context_hooks; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:466 + def with_around_example_hooks; end + + class << self + # Used to define methods that delegate to this example's metadata. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:48 + def delegate_to_metadata(key); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:122 + def parse_id(id); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example.rb:310 +RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + +# Represents the result of executing an example. +# Behaves like a hash for backwards compatibility. +# +# source://rspec-core-3.11.0/lib/rspec/core/example.rb:556 +class RSpec::Core::Example::ExecutionResult + include ::RSpec::Core::HashImitatable + extend ::RSpec::Core::HashImitatable::ClassMethods + + # Populates finished_at and run_time if it has not yet been set + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:610 + def ensure_timing_set(clock); end + + # @return [Boolean] Indicates if the example was completely skipped + # (typically done via `:skip` metadata or the `skip` method). Skipped examples + # will have a `:pending` result. A `:pending` result can also come from examples + # that were marked as `:pending`, which causes them to be run, and produces a + # `:failed` result if the example passes. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:597 + def example_skipped?; end + + # @return [Exception, nil] The failure, if there was one. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def exception; end + + # @return [Exception, nil] The failure, if there was one. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def exception=(_arg0); end + + # @return [Time] When the example finished. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def finished_at; end + + # @return [Time] When the example finished. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def finished_at=(_arg0); end + + # @return [Exception, nil] The exception triggered while + # executing the pending example. If no exception was triggered + # it would no longer get a status of `:pending` unless it was + # tagged with `:skip`. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_exception; end + + # @return [Exception, nil] The exception triggered while + # executing the pending example. If no exception was triggered + # it would no longer get a status of `:pending` unless it was + # tagged with `:skip`. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_exception=(_arg0); end + + # @return [Boolean] For examples tagged with `:pending`, + # this indicates whether or not it now passes. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_fixed; end + + # @return [Boolean] For examples tagged with `:pending`, + # this indicates whether or not it now passes. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_fixed=(_arg0); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:588 + def pending_fixed?; end + + # @return [String, nil] The reason the example was pending, + # or nil if the example was not pending. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_message; end + + # @return [String, nil] The reason the example was pending, + # or nil if the example was not pending. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def pending_message=(_arg0); end + + # Records the finished status of the example. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:603 + def record_finished(status, finished_at); end + + # @return [Float] How long the example took in seconds. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def run_time; end + + # @return [Float] How long the example took in seconds. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def run_time=(_arg0); end + + # @return [Time] When the example started. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def started_at; end + + # @return [Time] When the example started. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def started_at=(_arg0); end + + # @return [Symbol] `:passed`, `:failed` or `:pending`. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def status; end + + # @return [Symbol] `:passed`, `:failed` or `:pending`. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:442 + def status=(_arg0); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:616 + def calculate_run_time(finished_at); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:634 + def get_value(name); end + + # For backwards compatibility we present `status` as a string + # when presenting the legacy hash interface. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:623 + def hash_for_delegation; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:642 + def issue_deprecation(_method_name, *_args); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:629 + def set_value(name, value); end +end + +# Wraps both a `Proc` and an {Example} for use in {Hooks#around +# around} hooks. In around hooks we need to yield this special +# kind of object (rather than the raw {Example}) because when +# there are multiple `around` hooks we have to wrap them recursively. +# +# @example +# +# RSpec.configure do |c| +# c.around do |ex| # Procsy which wraps the example +# if ex.metadata[:key] == :some_value && some_global_condition +# raise "some message" +# end +# ex.run # run delegates to ex.call. +# end +# end +# @note This class also exposes the instance methods of {Example}, +# proxying them through to the wrapped {Example} instance. +# +# source://rspec-core-3.11.0/lib/rspec/core/example.rb:331 +class RSpec::Core::Example::Procsy + # @return [Procsy] a new instance of Procsy + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:362 + def initialize(example, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def <<(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def ===(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def >>(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def [](*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def arity(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def binding(*a, &b); end + + # Calls the proc and notes that the example has been executed. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:350 + def call(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def clock(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def clock=(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def clone(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def curry(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def description(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def dup(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def duplicate_with(*a, &b); end + + # The {Example} instance. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:333 + def example; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def example_group(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def example_group_instance(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def exception(*a, &b); end + + # Indicates whether or not the around hook has executed the example. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:374 + def executed?; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def execution_result(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def file_path(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def full_description(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def hash(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def id(*a, &b); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:379 + def inspect; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def inspect_output(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def lambda?(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def location(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def location_rerun_argument(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def metadata(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def parameters(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def pending(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def pending?(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def reporter(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def rerun_argument(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def ruby2_keywords(*a, &b); end + + # Calls the proc and notes that the example has been executed. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:350 + def run(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def skip(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def skipped?(*a, &b); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def source_location(*a, &b); end + + # Provides a wrapped proc that will update our `executed?` state when + # executed. + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:358 + def to_proc; end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:339 + def update_inherited_metadata(*a, &b); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:369 + def wrap(&block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:346 + def yield(*a, &b); end +end + +# ExampleGroup and {Example} are the main structural elements of +# rspec-core. Consider this example: +# +# RSpec.describe Thing do +# it "does something" do +# end +# end +# +# The object returned by `describe Thing` is a subclass of ExampleGroup. +# The object returned by `it "does something"` is an instance of Example, +# which serves as a wrapper for an instance of the ExampleGroup in which it +# is declared. +# +# Example group bodies (e.g. `describe` or `context` blocks) are evaluated +# in the context of a new subclass of ExampleGroup. Individual examples are +# evaluated in the context of an instance of the specific ExampleGroup +# subclass to which they belong. +# +# Besides the class methods defined here, there are other interesting macros +# defined in {Hooks}, {MemoizedHelpers::ClassMethods} and +# {SharedExampleGroup}. There are additional instance methods available to +# your examples defined in {MemoizedHelpers} and {Pending}. +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:29 +class RSpec::Core::ExampleGroup + include ::RSpec::Core::MemoizedHelpers + include ::RSpec::Core::Pending + extend ::RSpec::Core::Hooks + extend ::RSpec::Core::MemoizedHelpers::ClassMethods + extend ::RSpec::Core::SharedExampleGroup + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:707 + def initialize(inspect_output = T.unsafe(nil)); end + + # Returns the class or module passed to the `describe` method (or alias). + # Returns nil if the subject is not a class or module. + # + # @example + # RSpec.describe Thing do + # it "does something" do + # described_class == Thing + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:99 + def described_class; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:713 + def inspect; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:758 + def method_missing(name, *args); end + + class << self + # Adds an example to the example group + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:367 + def add_example(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:529 + def before_context_ivars; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:466 + def children; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def context(*args, &example_group_block); end + + # Returns true if a `before(:context)` or `after(:context)` + # hook is currently executing. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:542 + def currently_executing_a_context_hook?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:667 + def declaration_locations; end + + # @private + # @see DSL#describe + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:246 + def define_example_group_method(name, metadata = T.unsafe(nil)); end + + # @example + # $1 "does something", :slow, :load_factor => 100 do + # end + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:145 + def define_example_method(name, extra_options = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:317 + def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:76 + def delegate_to_metadata(*names); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:460 + def descendant_filtered_examples; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:503 + def descendants; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:78 + def described_class; end + + # @return [String] the current example group description + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:85 + def description; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:700 + def each_instance_variable_for_example(group); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:518 + def ensure_example_groups_are_configured; end + + # Defines an example within a group. + # + # @example + # example do + # end + # + # example "does something" do + # end + # + # example "does something", :slow, :uses_js do + # end + # + # example "does something", :with => 'additional metadata' do + # end + # + # example "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload example + # @overload example + # @overload example + # @overload example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def example(*all_args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def example_group(*args, &example_group_block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:450 + def examples; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def fdescribe(*args, &example_group_block); end + + # Shortcut to define an example with `:focus => true`. + # + # @example + # fexample do + # end + # + # fexample "does something" do + # end + # + # fexample "does something", :slow, :uses_js do + # end + # + # fexample "does something", :with => 'additional metadata' do + # end + # + # fexample "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload fexample + # @overload fexample + # @overload fexample + # @overload fexample + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def fexample(*all_args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:78 + def file_path; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:455 + def filtered_examples; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:379 + def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end + + # Shortcut to define an example with `:focus => true`. + # + # @example + # fit do + # end + # + # fit "does something" do + # end + # + # fit "does something", :slow, :uses_js do + # end + # + # fit "does something", :with => 'additional metadata' do + # end + # + # fit "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload fit + # @overload fit + # @overload fit + # @overload fit + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def fit(*all_args, &block); end + + # Shortcut to define an example with `:focus => true`. + # + # @example + # focus do + # end + # + # focus "does something" do + # end + # + # focus "does something", :slow, :uses_js do + # end + # + # focus "does something", :with => 'additional metadata' do + # end + # + # focus "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload focus + # @overload focus + # @overload focus + # @overload focus + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def focus(*all_args, &block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:655 + def for_filtered_examples(reporter, &block); end + + # Shortcut to define an example with `:focus => true`. + # + # @example + # fspecify do + # end + # + # fspecify "does something" do + # end + # + # fspecify "does something", :slow, :uses_js do + # end + # + # fspecify "does something", :with => 'additional metadata' do + # end + # + # fspecify "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload fspecify + # @overload fspecify + # @overload fspecify + # @overload fspecify + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def fspecify(*all_args, &block); end + + # @return [String] the unique id of this example group. Pass + # this at the command line to re-run this exact example group. + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:675 + def id; end + + # Define a singleton method for the singleton class (remove the method if + # it's already been defined). + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:40 + def idempotently_define_singleton_method(name, &definition); end + + # Includes shared content mapped to `name` directly in the group in which + # it is declared, as opposed to `it_behaves_like`, which creates a nested + # group. If given a block, that block is also eval'd in the current + # context. + # + # @see SharedExampleGroup + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:343 + def include_context(name, *args, &block); end + + # Includes shared content mapped to `name` directly in the group in which + # it is declared, as opposed to `it_behaves_like`, which creates a nested + # group. If given a block, that block is also eval'd in the current + # context. + # + # @see SharedExampleGroup + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:353 + def include_examples(name, *args, &block); end + + # Defines an example within a group. + # This is the primary API to define a code example. + # + # @example + # it do + # end + # + # it "does something" do + # end + # + # it "does something", :slow, :uses_js do + # end + # + # it "does something", :with => 'additional metadata' do + # end + # + # it "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload it + # @overload it + # @overload it + # @overload it + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def it(*all_args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:318 + def it_behaves_like(name, *args, &customization_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:318 + def it_should_behave_like(name, *args, &customization_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:78 + def location; end + + # The [Metadata](Metadata) object associated with this group. + # + # @see Metadata + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:51 + def metadata; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:485 + def next_runnable_index_for(file); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:625 + def ordering_strategy; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:508 + def parent_groups; end + + # Shortcut to define an example with `:pending => true` + # + # @example + # pending do + # end + # + # pending "does something" do + # end + # + # pending "does something", :slow, :uses_js do + # end + # + # pending "does something", :with => 'additional metadata' do + # end + # + # pending "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload pending + # @overload pending + # @overload pending + # @overload pending + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def pending(*all_args, &block); end + + # Removes an example from the example group + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:373 + def remove_example(example); end + + # Clear memoized values when adding/removing examples + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:359 + def reset_memoized; end + + # Runs all the examples in this group. + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:599 + def run(reporter = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:585 + def run_after_context_hooks(example_group_instance); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:547 + def run_before_context_hooks(example_group_instance); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:641 + def run_examples(reporter); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:410 + def set_it_up(description, args, registration_collection, &example_group_block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:685 + def set_ivars(instance, ivars); end + + # Shortcut to define an example with `:skip => true` + # + # @example + # skip do + # end + # + # skip "does something" do + # end + # + # skip "does something", :slow, :uses_js do + # end + # + # skip "does something", :with => 'additional metadata' do + # end + # + # skip "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload skip + # @overload skip + # @overload skip + # @overload skip + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def skip(*all_args, &block); end + + # Defines an example within a group. + # Useful for when your docstring does not read well off of `it`. + # + # @example + # RSpec.describe MyClass do + # specify "#do_something is deprecated" do + # # ... + # end + # end + # @example + # specify do + # end + # + # specify "does something" do + # end + # + # specify "does something", :slow, :uses_js do + # end + # + # specify "does something", :with => 'additional metadata' do + # end + # + # specify "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload specify + # @overload specify + # @overload specify + # @overload specify + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def specify(*all_args, &block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:534 + def store_before_context_ivars(example_group_instance); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:395 + def subclass(parent, description, args, registration_collection, &example_group_block); end + + # :nocov: + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:562 + def superclass_before_context_ivars; end + + # @private + # @return [Metadata] belonging to the parent of a nested {ExampleGroup} + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:71 + def superclass_metadata; end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:513 + def top_level?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:680 + def top_level_description; end + + # Traverses the tree of groups, starting with `self`, then the children, recursively. + # Halts the traversal of a branch of the tree as soon as the passed block returns true. + # Note that siblings groups and their sub-trees will continue to be explored. + # This is intended to make it easy to find the top-most group that satisfies some + # condition. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:476 + def traverse_tree_until(&block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:727 + def update_inherited_metadata(updates); end + + # Temporarily replace the provided metadata. + # Intended primarily to allow an example group's singleton class + # to return the metadata of the example that it exists for. This + # is necessary for shared example group inclusion to work properly + # with singleton example groups. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:61 + def with_replaced_metadata(meta); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:247 + def xdescribe(*args, &example_group_block); end + + # Shortcut to define an example with `:skip => 'Temporarily skipped with xexample'`. + # + # @example + # xexample do + # end + # + # xexample "does something" do + # end + # + # xexample "does something", :slow, :uses_js do + # end + # + # xexample "does something", :with => 'additional metadata' do + # end + # + # xexample "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload xexample + # @overload xexample + # @overload xexample + # @overload xexample + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def xexample(*all_args, &block); end + + # Shortcut to define an example with `:skip => 'Temporarily skipped with xit'`. + # + # @example + # xit do + # end + # + # xit "does something" do + # end + # + # xit "does something", :slow, :uses_js do + # end + # + # xit "does something", :with => 'additional metadata' do + # end + # + # xit "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload xit + # @overload xit + # @overload xit + # @overload xit + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def xit(*all_args, &block); end + + # Shortcut to define an example with `:skip => 'Temporarily skipped with xspecify'`. + # + # @example + # xspecify do + # end + # + # xspecify "does something" do + # end + # + # xspecify "does something", :slow, :uses_js do + # end + # + # xspecify "does something", :with => 'additional metadata' do + # end + # + # xspecify "does something" do |ex| + # # ex is the Example object that contains metadata about the example + # end + # @overload xspecify + # @overload xspecify + # @overload xspecify + # @overload xspecify + # @see example + # @yield [Example] the example object + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:146 + def xspecify(*all_args, &block); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:742 + def method_missing(name, *args); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:696 +RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol) + +# Raised when an RSpec API is called in the wrong scope, such as `before` +# being called from within an example rather than from within an example +# group block. +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:740 +class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end + +# Dumps a list of hashes in a pretty, human readable format +# for later parsing. The hashes are expected to have symbol +# keys and string values, and each hash should have the same +# set of keys. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:143 +class RSpec::Core::ExampleStatusDumper + # @return [ExampleStatusDumper] a new instance of ExampleStatusDumper + # + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:148 + def initialize(examples); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:152 + def dump; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:188 + def column_widths; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:159 + def formatted_header_rows; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:176 + def formatted_row_from(row_values); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:166 + def formatted_value_rows; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:184 + def headers; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:172 + def rows; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:144 + def dump(examples); end + end +end + +# Merges together a list of example statuses from this run +# and a list from previous runs (presumably loaded from disk). +# Each example status object is expected to be a hash with +# at least an `:example_id` and a `:status` key. Examples that +# were loaded but not executed (due to filtering, `--fail-fast` +# or whatever) should have a `:status` of `UNKNOWN_STATUS`. +# +# This willl produce a new list that: +# - Will be missing examples from previous runs that we know for sure +# no longer exist. +# - Will have the latest known status for any examples that either +# definitively do exist or may still exist. +# - Is sorted by file name and example definition order, so that +# the saved file is easily scannable if users want to inspect it. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:74 +class RSpec::Core::ExampleStatusMerger + # @return [ExampleStatusMerger] a new instance of ExampleStatusMerger + # + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:79 + def initialize(this_run, from_previous_runs); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:85 + def merge; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:102 + def delete_previous_examples_that_no_longer_exist; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:108 + def example_must_no_longer_exist?(ex_id); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:95 + def hash_from(example_list); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:124 + def loaded_spec_files; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:132 + def sort_value_from(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:128 + def spec_file_from(ex_id); end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:75 + def merge(this_run, from_previous_runs); end + end +end + +# Parses a string that has been previously dumped by ExampleStatusDumper. +# Note that this parser is a bit naive in that it does a simple split on +# "\n" and " | ", with no concern for handling escaping. For now, that's +# OK because the values we plan to persist (example id, status, and perhaps +# example duration) are highly unlikely to contain "\n" or " | " -- after +# all, who puts those in file names? +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:207 +class RSpec::Core::ExampleStatusParser + # @return [ExampleStatusParser] a new instance of ExampleStatusParser + # + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:212 + def initialize(string); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:216 + def parse; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:226 + def headers; end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:222 + def parse_row(line); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:230 + def split_line(line); end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:208 + def parse(string); end + end +end + +# Persists example ids and their statuses so that we can filter +# to just the ones that failed the last time they ran. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:8 +class RSpec::Core::ExampleStatusPersister + # @return [ExampleStatusPersister] a new instance of ExampleStatusPersister + # + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:18 + def initialize(examples, file_name); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:23 + def persist; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:40 + def dump_statuses(unparsed_previous_runs); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:46 + def statuses_from_this_run; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:9 + def load_from(file_name); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_status_persister.rb:14 + def persist(examples, file_name); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:183 +RSpec::Core::ExclusionRules = RSpec::Core::FilterRules + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:4 +class RSpec::Core::FilterManager + # @return [FilterManager] a new instance of FilterManager + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:7 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:22 + def add_ids(rerun_path, scoped_ids); end + + # @api private + # @param file_path [String] + # @param line_numbers [Array] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:15 + def add_location(file_path, line_numbers); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:30 + def empty?; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:57 + def exclude(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:61 + def exclude_only(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:65 + def exclude_with_low_priority(*args); end + + # Returns the value of attribute exclusions. + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:5 + def exclusions; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:69 + def include(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:73 + def include_only(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:77 + def include_with_low_priority(*args); end + + # Returns the value of attribute inclusions. + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:5 + def inclusions; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:34 + def prune(examples); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:83 + def add_path_to_arrays_filter(filter_key, path, values); end + + # When a user specifies a particular spec location, that takes priority + # over any exclusion filters (such as if the spec is tagged with `:slow` + # and there is a `:slow => true` exclusion filter), but only for specs + # defined in the same file as the location filters. Excluded specs in + # other files should still be excluded. + # + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:101 + def file_scoped_include?(ex_metadata, ids, locations); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:89 + def prune_conditionally_filtered_examples(examples); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:115 +class RSpec::Core::FilterRules + # @return [FilterRules] a new instance of FilterRules + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:130 + def initialize(rules = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:161 + def [](key); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:134 + def add(updated); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:138 + def add_with_low_priority(updated); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:149 + def clear; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:153 + def delete(key); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:173 + def description; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:169 + def each_pair(&block); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:165 + def empty?; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:157 + def fetch(*args, &block); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:177 + def include_example?(example); end + + # Returns the value of attribute opposite. + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:119 + def opposite; end + + # Sets the attribute opposite + # + # @param value the value to set the attribute opposite to. + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:119 + def opposite=(_arg0); end + + # Returns the value of attribute rules. + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:120 + def rules; end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:144 + def use_only(updated); end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:122 + def build; end + end +end + +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:116 +RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp) + +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:117 +RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String) + +# Tracks a collection of filterable items (e.g. modules, hooks, etc) +# and provides an optimized API to get the applicable items for the +# metadata of an example or example group. +# +# There are two implementations, optimized for different uses. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:87 +module RSpec::Core::FilterableItemRepository; end + +# This implementation is much more complex, and is optimized for +# rare (or hopefully no) updates once the queries start. Updates +# incur a cost as it has to clear the memoization and keep track +# of applicable keys. Queries will be O(N) the first time an item +# is provided with a given set of applicable metadata; subsequent +# queries with items with the same set of applicable metadata will +# be O(1) due to internal memoization. +# +# This is ideal for use by config, where filterable items (e.g. hooks) +# are typically added at the start of the process (e.g. in `spec_helper`) +# and then repeatedly queried as example groups and examples are defined. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:151 +class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized + # @return [QueryOptimized] a new instance of QueryOptimized + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:155 + def initialize(applies_predicate); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:164 + def append(item, metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:174 + def delete(item, metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:179 + def items_for(metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:169 + def prepend(item, metadata); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:217 + def applicable_metadata_from(metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:118 + def find_items_for(request_meta); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:211 + def handle_mutation(metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:235 + def proc_keys_from(metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:203 + def reconstruct_caches; end +end + +# This implementation is simple, and is optimized for frequent +# updates but rare queries. `append` and `prepend` do no extra +# processing, and no internal memoization is done, since this +# is not optimized for queries. +# +# This is ideal for use by a example or example group, which may +# be updated multiple times with globally configured hooks, etc, +# but will not be queried frequently by other examples or examle +# groups. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:98 +class RSpec::Core::FilterableItemRepository::UpdateOptimized + # @return [UpdateOptimized] a new instance of UpdateOptimized + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:101 + def initialize(applies_predicate); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:106 + def append(item, metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:114 + def delete(item, metadata); end + + # Returns the value of attribute items_and_filters. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:99 + def items_and_filters; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:118 + def items_for(request_meta); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:110 + def prepend(item, metadata); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/flat_map.rb:4 +module RSpec::Core::FlatMap + private + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/flat_map.rb:6 + def flat_map(array, &block); end + + class << self + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/flat_map.rb:6 + def flat_map(array, &block); end + end +end + +# ## Built-in Formatters +# +# * progress (default) - Prints dots for passing examples, `F` for failures, `*` +# for pending. +# * documentation - Prints the docstrings passed to `describe` and `it` methods +# (and their aliases). +# * html +# * json - Useful for archiving data for subsequent analysis. +# +# The progress formatter is the default, but you can choose any one or more of +# the other formatters by passing with the `--format` (or `-f` for short) +# command-line option, e.g. +# +# rspec --format documentation +# +# You can also send the output of multiple formatters to different streams, e.g. +# +# rspec --format documentation --format html --out results.html +# +# This example sends the output of the documentation formatter to `$stdout`, and +# the output of the html formatter to results.html. +# +# ## Custom Formatters +# +# You can tell RSpec to use a custom formatter by passing its path and name to +# the `rspec` command. For example, if you define MyCustomFormatter in +# path/to/my_custom_formatter.rb, you would type this command: +# +# rspec --require path/to/my_custom_formatter.rb --format MyCustomFormatter +# +# The reporter calls every formatter with this protocol: +# +# * To start +# * `start(StartNotification)` +# * Once per example group +# * `example_group_started(GroupNotification)` +# * Once per example +# * `example_started(ExampleNotification)` +# * One of these per example, depending on outcome +# * `example_passed(ExampleNotification)` +# * `example_failed(FailedExampleNotification)` +# * `example_pending(ExampleNotification)` +# * Optionally at any time +# * `message(MessageNotification)` +# * At the end of the suite +# * `stop(ExamplesNotification)` +# * `start_dump(NullNotification)` +# * `dump_pending(ExamplesNotification)` +# * `dump_failures(ExamplesNotification)` +# * `dump_summary(SummaryNotification)` +# * `seed(SeedNotification)` +# * `close(NullNotification)` +# +# Only the notifications to which you subscribe your formatter will be called +# on your formatter. To subscribe your formatter use: +# `RSpec::Core::Formatters#register` e.g. +# +# `RSpec::Core::Formatters.register FormatterClassName, :example_passed, :example_failed` +# +# We recommend you implement the methods yourself; for simplicity we provide the +# default formatter output via our notification objects but if you prefer you +# can subclass `RSpec::Core::Formatters::BaseTextFormatter` and override the +# methods you wish to enhance. +# +# @see RSpec::Core::Formatters::BaseTextFormatter +# @see RSpec::Core::Reporter +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:3 +module RSpec::Core::Formatters + class << self + # Register the formatter class + # + # @param formatter_class [Class] formatter class to register + # @param notifications [Array<Symbol>] one or more notifications to be + # registered to the specified formatter + # @see RSpec::Core::Formatters::BaseFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:86 + def register(formatter_class, *notifications); end + end +end + +# Contains common logic for formatters used by `--bisect` to communicate results +# back to the bisect runner. +# +# Subclasses must define a `notify_results(all_example_ids, failed_example_ids)` +# method. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:12 +class RSpec::Core::Formatters::BaseBisectFormatter + # @return [BaseBisectFormatter] a new instance of BaseBisectFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:17 + def initialize(expected_failures); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:23 + def example_failed(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:27 + def example_finished(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:37 + def start_dump(_notification); end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_bisect_formatter.rb:13 + def inherited(formatter); end + end +end + +# RSpec's built-in formatters are all subclasses of +# RSpec::Core::Formatters::BaseFormatter. +# +# @see RSpec::Core::Formatters::BaseTextFormatter +# @see RSpec::Core::Reporter +# @see RSpec::Core::Formatters::Protocol +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:13 +class RSpec::Core::Formatters::BaseFormatter + # @api public + # @param output [IO] the formatter output + # @return [BaseFormatter] a new instance of BaseFormatter + # @see RSpec::Core::Formatters::Protocol#initialize + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:23 + def initialize(output); end + + # @api public + # @param _notification [NullNotification] (Ignored) + # @see RSpec::Core::Formatters::Protocol#close + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:50 + def close(_notification); end + + # Returns the value of attribute example_group. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:17 + def example_group; end + + # Sets the attribute example_group + # + # @param value the value to set the attribute example_group to. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:17 + def example_group=(_arg0); end + + # @api public + # @param notification [GroupNotification] containing example_group + # subclass of `RSpec::Core::ExampleGroup` + # @see RSpec::Core::Formatters::Protocol#example_group_started + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:42 + def example_group_started(notification); end + + # Returns the value of attribute output. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:18 + def output; end + + # @api public + # @param notification [StartNotification] + # @see RSpec::Core::Formatters::Protocol#start + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:32 + def start(notification); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:64 + def output_supports_sync; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:60 + def restore_sync_output; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_formatter.rb:56 + def start_sync_output; end +end + +# Base for all of RSpec's built-in formatters. See +# RSpec::Core::Formatters::BaseFormatter to learn more about all of the +# methods called by the reporter. +# +# @see RSpec::Core::Formatters::BaseFormatter +# @see RSpec::Core::Reporter +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:12 +class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter + # Invoked at the end of a suite run. Allows the formatter to do any + # tidying up, but be aware that formatter output streams may be used + # elsewhere so don't actually close them. + # + # @api public + # @param _notification [NullNotification] (Ignored) + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:65 + def close(_notification); end + + # Dumps detailed information about each example failure. + # + # @api public + # @param notification [NullNotification] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:30 + def dump_failures(notification); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:47 + def dump_pending(notification); end + + # This method is invoked after the dumping of examples and failures. + # Each parameter is assigned to a corresponding attribute. + # + # @api public + # @param summary [SummaryNotification] containing duration, + # example_count, failure_count and pending_count + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:42 + def dump_summary(summary); end + + # Used by the reporter to send messages to the output stream. + # + # @api public + # @param notification [MessageNotification] containing message + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:21 + def message(notification); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/base_text_formatter.rb:53 + def seed(notification); end +end + +# Used by `--bisect`. When it shells out and runs a portion of the suite, it uses +# this formatter as a means to have the status reported back to it, via DRb. +# +# Note that since DRb calls carry considerable overhead compared to normal +# method calls, we try to minimize the number of DRb calls for perf reasons, +# opting to communicate only at the start and the end of the run, rather than +# after each example. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/bisect_drb_formatter.rb:15 +class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter + # @return [BisectDRbFormatter] a new instance of BisectDRbFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/bisect_drb_formatter.rb:16 + def initialize(_output); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/bisect_drb_formatter.rb:23 + def notify_results(results); end +end + +# ConsoleCodes provides helpers for formatting console output +# with ANSI codes, e.g. color's and bold. +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:6 +module RSpec::Core::Formatters::ConsoleCodes + private + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:34 + def config_colors_to_methods; end + + # Fetches the correct code for the supplied symbol, or checks + # that a code is valid. Defaults to white (37). + # + # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check + # @return [Fixnum] a console code + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:47 + def console_code_for(code_or_symbol); end + + # Wraps a piece of text in ANSI codes with the supplied code. Will + # only apply the control code if `RSpec.configuration.color_enabled?` + # returns true. + # + # @param text [String] the text to wrap + # @param code_or_symbol [Symbol, Fixnum] the desired control code + # @return [String] the wrapped text + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:66 + def wrap(text, code_or_symbol); end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:34 + def config_colors_to_methods; end + + # Fetches the correct code for the supplied symbol, or checks + # that a code is valid. Defaults to white (37). + # + # @param code_or_symbol [Symbol, Fixnum] Symbol or code to check + # @return [Fixnum] a console code + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:47 + def console_code_for(code_or_symbol); end + + # Wraps a piece of text in ANSI codes with the supplied code. Will + # only apply the control code if `RSpec.configuration.color_enabled?` + # returns true. + # + # @param text [String] the text to wrap + # @param code_or_symbol [Symbol, Fixnum] the desired control code + # @return [String] the wrapped text + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:66 + def wrap(text, code_or_symbol); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:8 +RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/console_codes.rb:29 +RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:7 +class RSpec::Core::Formatters::DeprecationFormatter + # @return [DeprecationFormatter] a new instance of DeprecationFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:12 + def initialize(deprecation_stream, summary_stream); end + + # Returns the value of attribute count. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:10 + def count; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:32 + def deprecation(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:44 + def deprecation_message_for(data); end + + # Returns the value of attribute deprecation_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:10 + def deprecation_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:40 + def deprecation_summary(_notification); end + + # Returns the value of attribute deprecation_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:10 + def output; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:20 + def printer; end + + # Returns the value of attribute summary_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:10 + def summary_stream; end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:60 +RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:135 +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + # @return [DelayedPrinter] a new instance of DelayedPrinter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:140 + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + # Returns the value of attribute deprecation_formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:138 + def deprecation_formatter; end + + # Returns the value of attribute deprecation_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:138 + def deprecation_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:163 + def deprecation_summary; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:172 + def print_deferred_deprecation_warnings; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:148 + def print_deprecation_message(data); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:155 + def stash_deprecation_message(deprecation_message); end + + # Returns the value of attribute summary_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:138 + def summary_stream; end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:136 +RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer) + +# Wraps a File object and provides file-specific operations. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:196 +class RSpec::Core::Formatters::DeprecationFormatter::FileStream + # @return [FileStream] a new instance of FileStream + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:197 + def initialize(file); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:207 + def puts(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:211 + def summarize(summary_stream, deprecation_count); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:94 +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct + # @return [GeneratedDeprecationMessage] a new instance of GeneratedDeprecationMessage + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:95 + def initialize(data); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:100 + def to_s; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:107 + def too_many_warnings_message; end + + # Returns the value of attribute type + # + # @return [Object] the current value of type + def type; end + + # Sets the attribute type + # + # @param value [Object] the value to set the attribute type to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:94 + def type=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:113 +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter + # @return [ImmediatePrinter] a new instance of ImmediatePrinter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:116 + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + # Returns the value of attribute deprecation_formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:114 + def deprecation_formatter; end + + # Returns the value of attribute deprecation_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:114 + def deprecation_stream; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:128 + def deprecation_summary; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:123 + def print_deprecation_message(data); end + + # Returns the value of attribute summary_stream. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:114 + def summary_stream; end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:52 +RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String) + +# Not really a stream, but is usable in place of one. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:184 +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream + # @raise [DeprecationError] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:185 + def puts(message); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:189 + def summarize(summary_stream, deprecation_count); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:66 +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct + # @return [SpecifiedDeprecationMessage] a new instance of SpecifiedDeprecationMessage + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:67 + def initialize(data); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:72 + def to_s; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:76 + def too_many_warnings_message; end + + # Returns the value of attribute type + # + # @return [Object] the current value of type + def type; end + + # Sets the attribute type + # + # @param value [Object] the value to set the attribute type to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:66 + def type=(_); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:88 + def deprecation_type_for(data); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:82 + def output_formatted(str); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/deprecation_formatter.rb:62 +RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:8 +class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter + # @return [DocumentationFormatter] a new instance of DocumentationFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:12 + def initialize(output); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:50 + def example_failed(failure); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:31 + def example_group_finished(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:24 + def example_group_started(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:35 + def example_passed(passed); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:42 + def example_pending(pending); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:20 + def example_started(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:57 + def message(notification); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:96 + def current_indentation(offset = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:85 + def failure_output(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:67 + def flush_messages; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:91 + def next_failure_index; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:75 + def passed_output(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/documentation_formatter.rb:79 + def pending_output(example, message); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:11 +class RSpec::Core::Formatters::ExceptionPresenter + # @return [ExceptionPresenter] a new instance of ExceptionPresenter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:16 + def initialize(exception, example, options = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:73 + def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:33 + def colorized_message_lines(colorizer = T.unsafe(nil)); end + + # Returns the value of attribute description. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def description; end + + # Returns the value of attribute example. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def example; end + + # Returns the value of attribute exception. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def exception; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:39 + def formatted_backtrace(exception = T.unsafe(nil)); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:45 + def formatted_cause(exception); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:79 + def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:84 + def fully_formatted_lines(failure_number, colorizer); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:29 + def message_lines; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:207 + def add_shared_group_lines(lines, colorizer); end + + # Returns the value of attribute backtrace_formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def backtrace_formatter; end + + # Returns the value of attribute detail_formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def detail_formatter; end + + # for 1.8.7 + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:261 + def encoded_description(description); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:115 + def encoded_string(string); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:111 + def encoding_of(string); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:271 + def exception_backtrace; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:145 + def exception_class_name(exception = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:185 + def exception_lines; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:178 + def exception_message_string(exception); end + + # Returns the value of attribute extra_detail_formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def extra_detail_formatter; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:196 + def extra_failure_lines; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:151 + def failure_lines; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:165 + def failure_slash_error_lines; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:99 + def final_exception(exception, previous = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:241 + def find_failed_line; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:252 + def formatted_message_and_backtrace(colorizer); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:129 + def indent_lines(lines, failure_number); end + + # Returns the value of attribute message_color. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:12 + def message_color; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:217 + def read_failed_lines; end +end + +# Configuring the `ExceptionPresenter` with the right set of options to handle +# pending vs failed vs skipped and aggregated (or not) failures is not simple. +# This class takes care of building an appropriate `ExceptionPresenter` for the +# provided example. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:280 +class RSpec::Core::Formatters::ExceptionPresenter::Factory + # @return [Factory] a new instance of Factory + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:287 + def initialize(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:281 + def build; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:338 + def multiple_exception_summarizer(exception, prior_detail_formatter, color); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:334 + def multiple_exceptions_error?(exception); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:297 + def options; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:301 + def pending_options; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:359 + def sub_failure_list_formatter(exception, message_color); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:318 + def with_multiple_error_options_as_needed(exception, options); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:392 +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater + # @return [CommonBacktraceTruncater] a new instance of CommonBacktraceTruncater + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:393 + def initialize(parent); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:397 + def with_truncated_backtrace(child); end +end + +# Used to prevent a confusing backtrace from showing up from the `aggregate_failures` +# block declared for `:aggregate_failures` metadata. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:385 +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter + class << self + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:386 + def format_backtrace(*_arg0); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:417 +RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/failure_list_formatter.rb:7 +class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter + # Discard profile and messages + # + # These outputs are not really relevant in the context of this failure + # list formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/failure_list_formatter.rb:18 + def dump_profile(_profile); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/failure_list_formatter.rb:10 + def example_failed(failure); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/failure_list_formatter.rb:19 + def message(_message); end +end + +# Formatter for providing message output as a fallback when no other +# profiler implements #message +# +# @api private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/fallback_message_formatter.rb:7 +class RSpec::Core::Formatters::FallbackMessageFormatter + # @api private + # @return [FallbackMessageFormatter] a new instance of FallbackMessageFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/fallback_message_formatter.rb:10 + def initialize(output); end + + # Used by the reporter to send messages to the output stream. + # + # @api public + # @param notification [MessageNotification] containing message + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/fallback_message_formatter.rb:22 + def message(notification); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/fallback_message_formatter.rb:15 + def output; end +end + +# Formatters helpers. +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:7 +module RSpec::Core::Formatters::Helpers + class << self + # Formats seconds into a human-readable string. + # + # @api private + # @example + # format_duration(1) #=> "1 minute 1 second" + # format_duration(135.14) #=> "2 minutes 15.14 seconds" + # @param duration [Float, Fixnum] in seconds + # @return [String] human-readable time + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:24 + def format_duration(duration); end + + # Formats seconds to have 5 digits of precision with trailing zeros + # removed if the number is less than 1 or with 2 digits of precision if + # the number is greater than zero. + # + # The precision used is set in {Helpers::SUB_SECOND_PRECISION} and + # {Helpers::DEFAULT_PRECISION}. + # + # @api private + # @example + # format_seconds(0.000006) #=> "0.00001" + # format_seconds(0.020000) #=> "0.02" + # format_seconds(1.00000000001) #=> "1" + # @param float [Float] + # @return [String] formatted float + # @see #strip_trailing_zeroes + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:60 + def format_seconds(float, precision = T.unsafe(nil)); end + + # Given a list of example ids, organizes them into a compact, ordered list. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:102 + def organize_ids(ids); end + + # Pluralize a word based on a count. + # + # @api private + # @param count [Fixnum] number of objects + # @param string [String] word to be pluralized + # @return [String] pluralized word + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:88 + def pluralize(count, string); end + + private + + # Remove trailing zeros from a string. + # + # Only remove trailing zeros after a decimal place. + # see: http://rubular.com/r/ojtTydOgpn + # + # @api private + # @param string [String] string with trailing zeros + # @return [String] string with trailing zeros removed + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:76 + def strip_trailing_zeroes(string); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:12 +RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/helpers.rb:9 +RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:8 +class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter + # @return [HtmlFormatter] a new instance of HtmlFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:13 + def initialize(output); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:103 + def dump_summary(summary); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:55 + def example_failed(failure); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:28 + def example_group_started(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:49 + def example_passed(passed); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:93 + def example_pending(pending); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:45 + def example_started(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:22 + def start(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:40 + def start_dump(_notification); end + + private + + # The number of the currently running example_group. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:120 + def example_group_number; end + + # The number of the currently running example (a global counter). + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:125 + def example_number; end + + # Override this method if you wish to output extra HTML for a failed + # spec. For example, you could output links to images or other files + # produced during the specs. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:141 + def extra_failure_content(failure); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_formatter.rb:130 + def percent_done; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:7 +class RSpec::Core::Formatters::HtmlPrinter + include ::ERB::Util + + # @return [HtmlPrinter] a new instance of HtmlPrinter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:9 + def initialize(output); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:81 + def flush; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:98 + def make_example_group_header_red(group_id); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:105 + def make_example_group_header_yellow(group_id); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:90 + def make_header_red; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:94 + def make_header_yellow; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:85 + def move_progress(percent_done); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:37 + def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:18 + def print_example_group_end; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:23 + def print_example_group_start(group_id, description, number_of_parents); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:29 + def print_example_passed(description, run_time); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:55 + def print_example_pending(description, pending_message); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:13 + def print_html_start; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:61 + def print_summary(duration, example_count, failure_count, pending_count); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:114 + def indentation_style(number_of_parents); end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:142 +RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String) + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:220 +RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String) + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:384 +RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String) + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/html_printer.rb:118 +RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:8 +class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter + # @return [JsonFormatter] a new instance of JsonFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:13 + def initialize(output); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:55 + def close(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:59 + def dump_profile(profile); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:78 + def dump_profile_slowest_example_groups(profile); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:66 + def dump_profile_slowest_examples(profile); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:24 + def dump_summary(summary); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:20 + def message(notification); end + + # Returns the value of attribute output_hash. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:11 + def output_hash; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:50 + def seed(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:35 + def stop(notification); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/json_formatter.rb:87 + def format_example(example); end +end + +# `RSpec::Core::Formatters::Loader` is an internal class for +# managing formatters used by a particular configuration. It is +# not expected to be used directly, but only through the configuration +# interface. +# +# @api private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:96 +class RSpec::Core::Formatters::Loader + # @api private + # @return [Loader] a new instance of Loader + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:105 + def initialize(reporter); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:144 + def add(formatter_to_use, *paths); end + + # @api private + # @return [String] the default formatter to setup, defaults to `progress` + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:118 + def default_formatter; end + + # @api private + # @return [String] the default formatter to setup, defaults to `progress` + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:118 + def default_formatter=(_arg0); end + + # @api private + # @return [Array] the loaded formatters + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:112 + def formatters; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:121 + def prepare_default(output_stream, deprecation_stream); end + + # @api private + # @return [Reporter] the reporter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:115 + def reporter; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:126 + def setup_default(output_stream, deprecation_stream); end + + private + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:211 + def built_in_formatter(key); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:234 + def custom_formatter(formatter_ref); end + + # @api private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:195 + def duplicate_formatter_exists?(new_formatter); end + + # @api private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:207 + def existing_formatter_implements?(notification); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:181 + def find_formatter(formatter_to_use); end + + # @api private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:202 + def has_matching_output?(formatter, new_formatter); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:228 + def notifications_for(formatter_class); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:269 + def open_stream(path_or_wrapper); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:250 + def path_for(const_ref); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:188 + def register(formatter, notifications); end + + # @api private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:246 + def string_const?(str); end + + # activesupport/lib/active_support/inflector/methods.rb, line 48 + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:259 + def underscore(camel_cased_word); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:254 + def underscore_with_fix_for_non_standard_rspec_naming(string); end + + class << self + # Internal formatters are stored here when loaded. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters.rb:100 + def formatters; end + end +end + +# Formatter for providing profile output. +# +# @api private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:8 +class RSpec::Core::Formatters::ProfileFormatter + # @api private + # @return [ProfileFormatter] a new instance of ProfileFormatter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:11 + def initialize(output); end + + # This method is invoked after the dumping the summary if profiling is + # enabled. + # + # @api public + # @param profile [ProfileNotification] containing duration, + # slowest_examples and slowest_example_groups + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:25 + def dump_profile(profile); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:16 + def output; end + + private + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:62 + def bold(text); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:44 + def dump_profile_slowest_example_groups(profile); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:32 + def dump_profile_slowest_examples(profile); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/profile_formatter.rb:57 + def format_caller(caller_info); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb:8 +class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter + # source://rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb:19 + def example_failed(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb:11 + def example_passed(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb:15 + def example_pending(_notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/progress_formatter.rb:23 + def start_dump(_notification); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:5 +class RSpec::Core::Formatters::SnippetExtractor + # @return [SnippetExtractor] a new instance of SnippetExtractor + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:35 + def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end + + # Returns the value of attribute beginning_line_number. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:24 + def beginning_line_number; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:41 + def expression_lines; end + + # Returns the value of attribute max_line_count. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:24 + def max_line_count; end + + # Returns the value of attribute source. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:24 + def source; end + + private + + # @raise [NoExpressionAtLineError] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:95 + def expression_node; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:107 + def expression_outmost_node?(node); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:55 + def line_range_of_expression; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:87 + def line_range_of_location_nodes_in_expression; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:117 + def location_nodes_at_beginning_line; end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:70 + def unclosed_tokens_in_line_range(line_range); end + + class << self + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:26 + def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end + + # @raise [NoSuchLineError] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:9 + def extract_line_at(file_path, line_number); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:128 + def least_indentation_from(lines); end + + # @raise [NoSuchFileError] + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:16 + def source_from_file(path); end + end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:22 +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError; end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:6 +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError; end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/snippet_extractor.rb:7 +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError; end + +# Provides terminal syntax highlighting of code snippets +# when coderay is available. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:7 +class RSpec::Core::Formatters::SyntaxHighlighter + # @return [SyntaxHighlighter] a new instance of SyntaxHighlighter + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:8 + def initialize(configuration); end + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:12 + def highlight(lines); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:50 + def color_enabled_implementation; end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:44 + def implementation; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:18 + def attempt_to_add_rspec_terms_to_coderay_keywords; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:61 +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + class << self + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:64 + def highlight_syntax(lines); end + end +end + +# source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:62 +RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:78 +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + class << self + # source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:79 + def highlight_syntax(lines); end + end +end + +# Not sure why, but our code above (and/or coderay itself) does not work +# on Windows, so we disable the feature on Windows. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/syntax_highlighter.rb:87 +RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + +# Mixin that makes the including class imitate a hash for backwards +# compatibility. The including class should use `attr_accessor` to +# declare attributes. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:349 +module RSpec::Core::HashImitatable + mixes_in_class_methods ::RSpec::Core::HashImitatable::ClassMethods + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def <(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def <=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def >(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def >=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:388 + def [](key); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:398 + def []=(key, value); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def all?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def any?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def assoc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def chain(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def chunk(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def chunk_while(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def clear(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def collect(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def collect_concat(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def compact(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def compact!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def compare_by_identity(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def compare_by_identity?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def count(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def cycle(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def deconstruct_keys(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def default(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def default=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def default_proc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def default_proc=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def delete(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def delete_if(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def detect(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def dig(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def drop(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def drop_while(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_cons(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_entry(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_key(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_pair(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_slice(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_value(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_with_index(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def each_with_object(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def empty?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def entries(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def fetch(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def fetch_values(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def filter(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def filter!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def filter_map(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def find(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def find_all(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def find_index(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def first(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def flat_map(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def flatten(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def grep(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def grep_v(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def group_by(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def has_key?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def has_value?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def include?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def index(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def inject(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def invert(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def keep_if(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def key(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def key?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def keys(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def lazy(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def length(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def map(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def max(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def max_by(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def member?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def merge(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def merge!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def min(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def min_by(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def minmax(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def minmax_by(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def none?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def one?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def partition(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def rassoc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def reduce(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def rehash(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def reject(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def reject!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def replace(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def reverse_each(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def select(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def select!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def shift(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def size(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def slice(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def slice_after(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def slice_before(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def slice_when(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def sort(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def sort_by(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def store(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def sum(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def take(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def take_while(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def tally(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def to_a(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:354 + def to_h; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def to_hash(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def to_proc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def to_set(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def transform_keys(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def transform_keys!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def transform_values(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def transform_values!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def uniq(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def update(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def value?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def values(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def values_at(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:367 + def zip(*args, &block); end + + private + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:414 + def directly_supports_attribute?(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:410 + def extra_hash_attributes; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:418 + def get_value(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:426 + def hash_for_delegation; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:430 + def issue_deprecation(_method_name, *_args); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:422 + def set_value(name, value); end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:350 + def included(klass); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:435 +module RSpec::Core::HashImitatable::ClassMethods + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:440 + def attr_accessor(*names); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:436 + def hash_attribute_names; end +end + +# Provides `before`, `after` and `around` hooks as a means of +# supporting common setup and teardown. This module is extended +# onto {ExampleGroup}, making the methods available from any `describe` +# or `context` block and included in {Configuration}, making them +# available off of the configuration object to define global setup +# or teardown logic. +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:9 +module RSpec::Core::Hooks + # Declare a block of code to be run after each example (using `:example`) + # or once after all examples n the context (using `:context`). See + # {#before} for more information about ordering. + # + # ### Exceptions + # + # `after` hooks are guaranteed to run even when there are exceptions in + # `before` hooks or examples. When an exception is raised in an after + # block, the exception is captured for later reporting, and subsequent + # `after` blocks are run. + # + # ### Order + # + # `after` hooks are stored in three scopes, which are run in order: + # `:example`, `:context`, and `:suite`. They can also be declared in + # several different places: `RSpec.configure`, a parent group, the current + # group. They are run in the following order: + # + # after(:example) # Declared in the current group. + # after(:example) # Declared in a parent group. + # after(:example) # Declared in RSpec.configure. + # after(:context) # Declared in the current group. + # after(:context) # Declared in a parent group. + # after(:context) # Declared in RSpec.configure. + # after(:suite) # Declared in RSpec.configure. + # + # This is the reverse of the order in which `before` hooks are run. + # Similarly, if more than one `after` is declared within any example + # group, they are run in reverse order of that in which they are declared. + # Also `around` hooks will run after any `after` example hooks are + # invoked but before any `after` context hooks. + # + # @api public + # @note The `:suite` scope is only supported for hooks registered on + # `RSpec.configuration` since they exist independently of any + # example or example group. + # @note The `:example` and `:context` scopes are also available as + # `:each` and `:all`, respectively. Use whichever you prefer. + # @overload after + # @overload after + # @overload after + # @overload after + # @see #before + # @see #around + # @see ExampleGroup + # @see SharedContext + # @see SharedExampleGroup + # @see Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:277 + def after(*args, &block); end + + # Adds `block` to the back of the list of `after` blocks in the same + # scope (`:example`, `:context`, or `:suite`). + # + # See {#after} for scoping semantics. + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:287 + def append_after(*args, &block); end + + # Declare a block of code to be run before each example (using `:example`) + # or once before any example (using `:context`). These are usually + # declared directly in the {ExampleGroup} to which they apply, but they + # can also be shared across multiple groups. + # + # You can also use `before(:suite)` to run a block of code before any + # example groups are run. This should be declared in {RSpec.configure}. + # + # Instance variables declared in `before(:example)` or `before(:context)` + # are accessible within each example. + # + # ### Order + # + # `before` hooks are stored in three scopes, which are run in order: + # `:suite`, `:context`, and `:example`. They can also be declared in + # several different places: `RSpec.configure`, a parent group, the current + # group. They are run in the following order: + # + # before(:suite) # Declared in RSpec.configure. + # before(:context) # Declared in RSpec.configure. + # before(:context) # Declared in a parent group. + # before(:context) # Declared in the current group. + # before(:example) # Declared in RSpec.configure. + # before(:example) # Declared in a parent group. + # before(:example) # Declared in the current group. + # + # If more than one `before` is declared within any one example group, they + # are run in the order in which they are declared. Any `around` hooks will + # execute after `before` context hooks but before any `before` example + # hook regardless of where they are declared. + # + # ### Conditions + # + # When you add a conditions hash to `before(:example)` or + # `before(:context)`, RSpec will only apply that hook to groups or + # examples that match the conditions. e.g. + # + # RSpec.configure do |config| + # config.before(:example, :authorized => true) do + # log_in_as :authorized_user + # end + # end + # + # RSpec.describe Something, :authorized => true do + # # The before hook will run in before each example in this group. + # end + # + # RSpec.describe SomethingElse do + # it "does something", :authorized => true do + # # The before hook will run before this example. + # end + # + # it "does something else" do + # # The hook will not run before this example. + # end + # end + # + # Note that filtered config `:context` hooks can still be applied + # to individual examples that have matching metadata. Just like + # Ruby's object model is that every object has a singleton class + # which has only a single instance, RSpec's model is that every + # example has a singleton example group containing just the one + # example. + # + # ### Warning: `before(:suite, :with => :conditions)` + # + # The conditions hash is used to match against specific examples. Since + # `before(:suite)` is not run in relation to any specific example or + # group, conditions passed along with `:suite` are effectively ignored. + # + # ### Exceptions + # + # When an exception is raised in a `before` block, RSpec skips any + # subsequent `before` blocks and the example, but runs all of the + # `after(:example)` and `after(:context)` hooks. + # + # ### Warning: implicit before blocks + # + # `before` hooks can also be declared in shared contexts which get + # included implicitly either by you or by extension libraries. Since + # RSpec runs these in the order in which they are declared within each + # scope, load order matters, and can lead to confusing results when one + # before block depends on state that is prepared in another before block + # that gets run later. + # + # ### Warning: `before(:context)` + # + # It is very tempting to use `before(:context)` to speed things up, but we + # recommend that you avoid this as there are a number of gotchas, as well + # as things that simply don't work. + # + # #### Context + # + # `before(:context)` is run in an example that is generated to provide + # group context for the block. + # + # #### Instance variables + # + # Instance variables declared in `before(:context)` are shared across all + # the examples in the group. This means that each example can change the + # state of a shared object, resulting in an ordering dependency that can + # make it difficult to reason about failures. + # + # #### Unsupported RSpec constructs + # + # RSpec has several constructs that reset state between each example + # automatically. These are not intended for use from within + # `before(:context)`: + # + # * `let` declarations + # * `subject` declarations + # * Any mocking, stubbing or test double declaration + # + # ### other frameworks + # + # Mock object frameworks and database transaction managers (like + # ActiveRecord) are typically designed around the idea of setting up + # before an example, running that one example, and then tearing down. This + # means that mocks and stubs can (sometimes) be declared in + # `before(:context)`, but get torn down before the first real example is + # ever run. + # + # You _can_ create database-backed model objects in a `before(:context)` + # in rspec-rails, but it will not be wrapped in a transaction for you, so + # you are on your own to clean up in an `after(:context)` block. + # + # @api public + # @example before(:example) declared in an {ExampleGroup} + # RSpec.describe Thing do + # before(:example) do + # @thing = Thing.new + # end + # + # it "does something" do + # # Here you can access @thing. + # end + # end + # @example before(:context) declared in an {ExampleGroup} + # RSpec.describe Parser do + # before(:context) do + # File.open(file_to_parse, 'w') do |f| + # f.write <<-CONTENT + # stuff in the file + # CONTENT + # end + # end + # + # it "parses the file" do + # Parser.parse(file_to_parse) + # end + # + # after(:context) do + # File.delete(file_to_parse) + # end + # end + # @note The `:example` and `:context` scopes are also available as + # `:each` and `:all`, respectively. Use whichever you prefer. + # @note The `:suite` scope is only supported for hooks registered on + # `RSpec.configuration` since they exist independently of any + # example or example group. + # @overload before + # @overload before + # @overload before + # @overload before + # @see #after + # @see #around + # @see ExampleGroup + # @see SharedContext + # @see SharedExampleGroup + # @see Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:200 + def append_before(*args, &block); end + + # Declare a block of code, parts of which will be run before and parts + # after the example. It is your responsibility to run the example: + # + # around(:example) do |ex| + # # Do some stuff before. + # ex.run + # # Do some stuff after. + # end + # + # The yielded example aliases `run` with `call`, which lets you treat it + # like a `Proc`. This is especially handy when working with libraries + # that manage their own setup and teardown using a block or proc syntax, + # e.g. + # + # around(:example) {|ex| Database.transaction(&ex)} + # around(:example) {|ex| FakeFS(&ex)} + # + # ### Order + # + # The `around` hooks execute surrounding an example and its hooks. + # + # This means after any `before` context hooks, but before any `before` + # example hooks, and similarly after any `after` example hooks but before + # any `after` context hooks. + # + # They are not a synonym for `before`/`after`. + # + # @api public + # @note `:example`/`:each` is the only supported scope. + # @note the syntax of `around` is similar to that of `before` and `after` + # but the semantics are quite different. `before` and `after` hooks are + # run in the context of the examples with which they are associated, + # whereas `around` hooks are actually responsible for running the + # examples. Consequently, `around` hooks do not have direct access to + # resources that are made available within the examples and their + # associated `before` and `after` hooks. + # @overload around + # @overload around + # @overload around + # @overload around + # @yield [Example] the example to run + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:349 + def around(*args, &block); end + + # Declare a block of code to be run before each example (using `:example`) + # or once before any example (using `:context`). These are usually + # declared directly in the {ExampleGroup} to which they apply, but they + # can also be shared across multiple groups. + # + # You can also use `before(:suite)` to run a block of code before any + # example groups are run. This should be declared in {RSpec.configure}. + # + # Instance variables declared in `before(:example)` or `before(:context)` + # are accessible within each example. + # + # ### Order + # + # `before` hooks are stored in three scopes, which are run in order: + # `:suite`, `:context`, and `:example`. They can also be declared in + # several different places: `RSpec.configure`, a parent group, the current + # group. They are run in the following order: + # + # before(:suite) # Declared in RSpec.configure. + # before(:context) # Declared in RSpec.configure. + # before(:context) # Declared in a parent group. + # before(:context) # Declared in the current group. + # before(:example) # Declared in RSpec.configure. + # before(:example) # Declared in a parent group. + # before(:example) # Declared in the current group. + # + # If more than one `before` is declared within any one example group, they + # are run in the order in which they are declared. Any `around` hooks will + # execute after `before` context hooks but before any `before` example + # hook regardless of where they are declared. + # + # ### Conditions + # + # When you add a conditions hash to `before(:example)` or + # `before(:context)`, RSpec will only apply that hook to groups or + # examples that match the conditions. e.g. + # + # RSpec.configure do |config| + # config.before(:example, :authorized => true) do + # log_in_as :authorized_user + # end + # end + # + # RSpec.describe Something, :authorized => true do + # # The before hook will run in before each example in this group. + # end + # + # RSpec.describe SomethingElse do + # it "does something", :authorized => true do + # # The before hook will run before this example. + # end + # + # it "does something else" do + # # The hook will not run before this example. + # end + # end + # + # Note that filtered config `:context` hooks can still be applied + # to individual examples that have matching metadata. Just like + # Ruby's object model is that every object has a singleton class + # which has only a single instance, RSpec's model is that every + # example has a singleton example group containing just the one + # example. + # + # ### Warning: `before(:suite, :with => :conditions)` + # + # The conditions hash is used to match against specific examples. Since + # `before(:suite)` is not run in relation to any specific example or + # group, conditions passed along with `:suite` are effectively ignored. + # + # ### Exceptions + # + # When an exception is raised in a `before` block, RSpec skips any + # subsequent `before` blocks and the example, but runs all of the + # `after(:example)` and `after(:context)` hooks. + # + # ### Warning: implicit before blocks + # + # `before` hooks can also be declared in shared contexts which get + # included implicitly either by you or by extension libraries. Since + # RSpec runs these in the order in which they are declared within each + # scope, load order matters, and can lead to confusing results when one + # before block depends on state that is prepared in another before block + # that gets run later. + # + # ### Warning: `before(:context)` + # + # It is very tempting to use `before(:context)` to speed things up, but we + # recommend that you avoid this as there are a number of gotchas, as well + # as things that simply don't work. + # + # #### Context + # + # `before(:context)` is run in an example that is generated to provide + # group context for the block. + # + # #### Instance variables + # + # Instance variables declared in `before(:context)` are shared across all + # the examples in the group. This means that each example can change the + # state of a shared object, resulting in an ordering dependency that can + # make it difficult to reason about failures. + # + # #### Unsupported RSpec constructs + # + # RSpec has several constructs that reset state between each example + # automatically. These are not intended for use from within + # `before(:context)`: + # + # * `let` declarations + # * `subject` declarations + # * Any mocking, stubbing or test double declaration + # + # ### other frameworks + # + # Mock object frameworks and database transaction managers (like + # ActiveRecord) are typically designed around the idea of setting up + # before an example, running that one example, and then tearing down. This + # means that mocks and stubs can (sometimes) be declared in + # `before(:context)`, but get torn down before the first real example is + # ever run. + # + # You _can_ create database-backed model objects in a `before(:context)` + # in rspec-rails, but it will not be wrapped in a transaction for you, so + # you are on your own to clean up in an `after(:context)` block. + # + # @api public + # @example before(:example) declared in an {ExampleGroup} + # + # RSpec.describe Thing do + # before(:example) do + # @thing = Thing.new + # end + # + # it "does something" do + # # Here you can access @thing. + # end + # end + # @example before(:context) declared in an {ExampleGroup} + # + # RSpec.describe Parser do + # before(:context) do + # File.open(file_to_parse, 'w') do |f| + # f.write <<-CONTENT + # stuff in the file + # CONTENT + # end + # end + # + # it "parses the file" do + # Parser.parse(file_to_parse) + # end + # + # after(:context) do + # File.delete(file_to_parse) + # end + # end + # @note The `:example` and `:context` scopes are also available as + # `:each` and `:all`, respectively. Use whichever you prefer. + # @note The `:suite` scope is only supported for hooks registered on + # `RSpec.configuration` since they exist independently of any + # example or example group. + # @overload before + # @overload before + # @overload before + # @overload before + # @see #after + # @see #around + # @see ExampleGroup + # @see SharedContext + # @see SharedExampleGroup + # @see Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:200 + def before(*args, &block); end + + # Holds the various registered hooks. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:355 + def hooks; end + + # Declare a block of code to be run after each example (using `:example`) + # or once after all examples n the context (using `:context`). See + # {#before} for more information about ordering. + # + # ### Exceptions + # + # `after` hooks are guaranteed to run even when there are exceptions in + # `before` hooks or examples. When an exception is raised in an after + # block, the exception is captured for later reporting, and subsequent + # `after` blocks are run. + # + # ### Order + # + # `after` hooks are stored in three scopes, which are run in order: + # `:example`, `:context`, and `:suite`. They can also be declared in + # several different places: `RSpec.configure`, a parent group, the current + # group. They are run in the following order: + # + # after(:example) # Declared in the current group. + # after(:example) # Declared in a parent group. + # after(:example) # Declared in RSpec.configure. + # after(:context) # Declared in the current group. + # after(:context) # Declared in a parent group. + # after(:context) # Declared in RSpec.configure. + # after(:suite) # Declared in RSpec.configure. + # + # This is the reverse of the order in which `before` hooks are run. + # Similarly, if more than one `after` is declared within any example + # group, they are run in reverse order of that in which they are declared. + # Also `around` hooks will run after any `after` example hooks are + # invoked but before any `after` context hooks. + # + # @api public + # @note The `:suite` scope is only supported for hooks registered on + # `RSpec.configuration` since they exist independently of any + # example or example group. + # @note The `:example` and `:context` scopes are also available as + # `:each` and `:all`, respectively. Use whichever you prefer. + # @overload after + # @overload after + # @overload after + # @overload after + # @see #before + # @see #around + # @see ExampleGroup + # @see SharedContext + # @see SharedExampleGroup + # @see Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:277 + def prepend_after(*args, &block); end + + # Adds `block` to the front of the list of `before` blocks in the same + # scope (`:example`, `:context`, or `:suite`). + # + # See {#before} for scoping semantics. + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:210 + def prepend_before(*args, &block); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:379 +class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:380 + def run(example); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:370 +class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:371 + def run(example); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:388 +class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:389 + def execute_with(example, procsy); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:397 + def hook_description; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:363 +class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:364 + def run(example); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:360 +class RSpec::Core::Hooks::Hook < ::Struct + # Returns the value of attribute block + # + # @return [Object] the current value of block + def block; end + + # Sets the attribute block + # + # @param value [Object] the value to set the attribute block to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:360 + def block=(_); end + + # Returns the value of attribute options + # + # @return [Object] the current value of options + def options; end + + # Sets the attribute options + # + # @param value [Object] the value to set the attribute options to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:360 + def options=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# This provides the primary API used by other parts of rspec-core. By hiding all +# implementation details behind this facade, it's allowed us to heavily optimize +# this, so that, for example, hook collection objects are only instantiated when +# a hook is added. This allows us to avoid many object allocations for the common +# case of a group having no hooks. +# +# This is only possible because this interface provides a "tell, don't ask"-style +# API, so that callers _tell_ this class what to do with the hooks, rather than +# asking this class for a list of hooks, and then doing something with them. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:420 +class RSpec::Core::Hooks::HookCollections + # @return [HookCollections] a new instance of HookCollections + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:421 + def initialize(owner, filterable_item_repo_class); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:449 + def register(prepend_or_append, position, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:442 + def register_global_singleton_context_hooks(example, globals); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:431 + def register_globals(host, globals); end + + # Runs all of the blocks stored with the hook in the context of the + # example. If no example is provided, just calls the hook directly. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:475 + def run(position, scope, example_or_group); end + + protected + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:523 + def all_hooks_for(position, scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:507 + def matching_hooks_for(position, scope, example_or_group); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:533 + def processable_hooks_for(position, scope, host); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:527 + def run_owned_hooks_for(position, scope, example_or_group); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:553 + def ensure_hooks_initialized_for(position, scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:591 + def extract_scope_from(args); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:543 + def hooks_for(position, scope); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:605 + def known_scope?(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:609 + def normalized_scope_for(scope); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:633 + def owner_parent_groups; end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:571 + def process(host, parent_groups, globals, position, scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:619 + def run_around_example_hooks_for(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:613 + def run_example_hooks_for(example, position, each_method); end + + # source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:584 + def scope_and_options_from(*args); end +end + +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:505 +RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array) + +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:495 +RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash) + +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:491 +RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array) + +# source://rspec-core-3.11.0/lib/rspec/core/hooks.rb:493 +RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:186 +class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:187 + def add(*args); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:191 + def add_with_low_priority(*args); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:195 + def include_example?(example); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:203 + def split_file_scoped_rules; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:199 + def standalone?; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:213 + def apply_standalone_filter(updated); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:226 + def is_standalone_filter?(rules); end + + # source://rspec-core-3.11.0/lib/rspec/core/filter_manager.rb:221 + def replace_filters(new_rules); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:4 +module RSpec::Core::Invocations; end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:28 +class RSpec::Core::Invocations::Bisect + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:29 + def call(options, err, out); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:45 + def bisect_formatter_klass_for(argument); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:15 +class RSpec::Core::Invocations::DRbWithFallback + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:16 + def call(options, err, out); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:6 +class RSpec::Core::Invocations::InitializeProject + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:7 + def call(*_args); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:78 +class RSpec::Core::Invocations::PrintHelp < ::Struct + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:79 + def call(_options, _err, out); end + + # Returns the value of attribute hidden_options + # + # @return [Object] the current value of hidden_options + def hidden_options; end + + # Sets the attribute hidden_options + # + # @param value [Object] the value to set the attribute hidden_options to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:78 + def hidden_options=(_); end + + # Returns the value of attribute parser + # + # @return [Object] the current value of parser + def parser; end + + # Sets the attribute parser + # + # @param value [Object] the value to set the attribute parser to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:78 + def parser=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:52 +class RSpec::Core::Invocations::PrintVersion + # source://rspec-core-3.11.0/lib/rspec/core/invocations.rb:53 + def call(_options, _err, out); end +end + +# Together with the example group metadata hash default block, +# provides backwards compatibility for the old `:example_group` +# key. In RSpec 2.x, the computed keys of a group's metadata +# were exposed from a nested subhash keyed by `[:example_group]`, and +# then the parent group's metadata was exposed by sub-subhash +# keyed by `[:example_group][:example_group]`. +# +# In RSpec 3, we reorganized this to that the computed keys are +# exposed directly of the group metadata hash (no nesting), and +# `:parent_example_group` returns the parent group's metadata. +# +# Maintaining backwards compatibility was difficult: we wanted +# `:example_group` to return an object that: +# +# * Exposes the top-level metadata keys that used to be nested +# under `:example_group`. +# * Supports mutation (rspec-rails, for example, assigns +# `metadata[:example_group][:described_class]` when you use +# anonymous controller specs) such that changes are written +# back to the top-level metadata hash. +# * Exposes the parent group metadata as +# `[:example_group][:example_group]`. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:470 +class RSpec::Core::LegacyExampleGroupHash + include ::RSpec::Core::HashImitatable + extend ::RSpec::Core::HashImitatable::ClassMethods + + # @return [LegacyExampleGroupHash] a new instance of LegacyExampleGroupHash + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:473 + def initialize(metadata); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:479 + def to_h; end + + private + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:485 + def directly_supports_attribute?(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:489 + def get_value(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:493 + def set_value(name, value); end +end + +# This module is included in {ExampleGroup}, making the methods +# available to be called from within example blocks. +# +# @see ClassMethods +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:9 +module RSpec::Core::MemoizedHelpers + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:135 + def initialize(*_arg0); end + + # Wraps the `subject` in `expect` to make it the target of an expectation. + # Designed to read nicely for one-liners. + # + # @example + # + # describe [1, 2, 3] do + # it { is_expected.to be_an Array } + # it { is_expected.not_to include 4 } + # end + # @note This only works if you are using rspec-expectations. + # @see #subject + # @see #should + # @see #should_not + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:120 + def is_expected; end + + # When `should` is called with no explicit receiver, the call is + # delegated to the object returned by `subject`. Combined with an + # implicit subject this supports very concise expressions. + # + # @example + # + # RSpec.describe Person do + # it { should be_eligible_to_vote } + # end + # @note This only works if you are using rspec-expectations. + # @note If you are using RSpec's newer expect-based syntax you may + # want to use `is_expected.to` instead of `should`. + # @see #subject + # @see #is_expected + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:80 + def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end + + # Just like `should`, `should_not` delegates to the subject (implicit or + # explicit) of the example group. + # + # @example + # + # RSpec.describe Person do + # it { should_not be_eligible_to_vote } + # end + # @note This only works if you are using rspec-expectations. + # @note If you are using RSpec's newer expect-based syntax you may + # want to use `is_expected.to_not` instead of `should_not`. + # @see #subject + # @see #is_expected + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:100 + def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end + + # @example + # + # # Explicit declaration of subject. + # RSpec.describe Person do + # subject { Person.new(:birthdate => 19.years.ago) } + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # # ^ ^ explicit reference to subject not recommended + # end + # end + # + # # Implicit subject => { Person.new }. + # RSpec.describe Person do + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # # ^ ^ explicit reference to subject not recommended + # end + # end + # + # # One-liner syntax - expectation is set on the subject. + # RSpec.describe Person do + # it { is_expected.to be_eligible_to_vote } + # # or + # it { should be_eligible_to_vote } + # end + # @note `subject` was contributed by Joe Ferris to support the one-liner + # syntax embraced by shoulda matchers: + # + # RSpec.describe Widget do + # it { is_expected.to validate_presence_of(:name) } + # # or + # it { should validate_presence_of(:name) } + # end + # + # While the examples below demonstrate how to use `subject` + # explicitly in examples, we recommend that you define a method with + # an intention revealing name instead. + # @note Because `subject` is designed to create state that is reset + # between each example, and `before(:context)` is designed to setup + # state that is shared across _all_ examples in an example group, + # `subject` is _not_ intended to be used in a `before(:context)` hook. + # @see #should + # @see #should_not + # @see #is_expected + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:57 + def subject; end + + private + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:141 + def __init_memoized; end + + # should just be placed in private section, + # but Ruby issues warnings on private attributes. + # and expanding it to the equivalent method upsets Rubocop, + # b/c it should obviously be a reader + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:129 + def __memoized; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:150 + def enforce_value_expectation(matcher, method_name); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:163 + def matcher_supports_value_expectations?(matcher); end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:542 + def define_helpers_on(example_group); end + + # Gets the named constant or yields. + # On 1.9, const_defined? / const_get take into account the + # the inheritance by default, and accept an argument to + # disable this behavior. It's important that we don't + # consider inheritance here; each example group level that + # uses a `let` should get its own `LetDefinitions` module. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:570 + def get_constant_or_yield(example_group, name); end + + # Gets the LetDefinitions module. The module is mixed into + # the example group and is used to hold all let definitions. + # This is done so that the block passed to `let` can be + # forwarded directly on to `define_method`, so that all method + # constructs (including `super` and `return`) can be used in + # a `let` block. + # + # The memoization is provided by a method definition on the + # example group that supers to the LetDefinitions definition + # in order to get the value to memoize. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:528 + def module_for(example_group); end + end +end + +# This module is extended onto {ExampleGroup}, making the methods +# available to be called from within example group blocks. +# You can think of them as being analagous to class macros. +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:274 +module RSpec::Core::MemoizedHelpers::ClassMethods + # Generates a method whose return value is memoized after the first + # call. Useful for reducing duplication between examples that assign + # values to the same local variable. + # + # @example + # + # RSpec.describe Thing do + # let(:thing) { Thing.new } + # + # it "does something" do + # # First invocation, executes block, memoizes and returns result. + # thing.do_something + # + # # Second invocation, returns the memoized value. + # thing.should be_something + # end + # end + # @note `let` _can_ enhance readability when used sparingly (1,2, or + # maybe 3 declarations) in any given example group, but that can + # quickly degrade with overuse. YMMV. + # @note `let` can be configured to be threadsafe or not. + # If it is threadsafe, it will take longer to access the value. + # If it is not threadsafe, it may behave in surprising ways in examples + # that spawn separate threads. Specify this on `RSpec.configure` + # @note Because `let` is designed to create state that is reset between + # each example, and `before(:context)` is designed to setup state that + # is shared across _all_ examples in an example group, `let` is _not_ + # intended to be used in a `before(:context)` hook. + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:306 + def let(name, &block); end + + # Just like `let`, except the block is invoked by an implicit `before` + # hook. This serves a dual purpose of setting up state and providing a + # memoized reference to that state. + # + # @example + # + # class Thing + # def self.count + # @count ||= 0 + # end + # + # def self.count=(val) + # @count += val + # end + # + # def self.reset_count + # @count = 0 + # end + # + # def initialize + # self.class.count += 1 + # end + # end + # + # RSpec.describe Thing do + # after(:example) { Thing.reset_count } + # + # context "using let" do + # let(:thing) { Thing.new } + # + # it "is not invoked implicitly" do + # Thing.count.should eq(0) + # end + # + # it "can be invoked explicitly" do + # thing + # Thing.count.should eq(1) + # end + # end + # + # context "using let!" do + # let!(:thing) { Thing.new } + # + # it "is invoked implicitly" do + # Thing.count.should eq(1) + # end + # + # it "returns memoized version on first invocation" do + # thing + # Thing.count.should eq(1) + # end + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:400 + def let!(name, &block); end + + # Declares a `subject` for an example group which can then be wrapped + # with `expect` using `is_expected` to make it the target of an + # expectation in a concise, one-line example. + # + # Given a `name`, defines a method with that name which returns the + # `subject`. This lets you declare the subject once and access it + # implicitly in one-liners and explicitly using an intention revealing + # name. + # + # When given a `name`, calling `super` in the block is not supported. + # + # @example + # + # RSpec.describe CheckingAccount, "with $50" do + # subject { CheckingAccount.new(Money.new(50, :USD)) } + # it { is_expected.to have_a_balance_of(Money.new(50, :USD)) } + # it { is_expected.not_to be_overdrawn } + # end + # + # RSpec.describe CheckingAccount, "with a non-zero starting balance" do + # subject(:account) { CheckingAccount.new(Money.new(50, :USD)) } + # it { is_expected.not_to be_overdrawn } + # it "has a balance equal to the starting balance" do + # account.balance.should eq(Money.new(50, :USD)) + # end + # end + # @note `subject` can be configured to be threadsafe or not. + # If it is threadsafe, it will take longer to access the value. + # If it is not threadsafe, it may behave in surprising ways in examples + # that spawn separate threads. Specify this on `RSpec.configure` + # @param name [String, Symbol] used to define an accessor with an + # intention revealing name + # @param block defines the value to be returned by `subject` in examples + # @see MemoizedHelpers#should + # @see MemoizedHelpers#should_not + # @see MemoizedHelpers#is_expected + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:444 + def subject(name = T.unsafe(nil), &block); end + + # Just like `subject`, except the block is invoked by an implicit + # `before` hook. This serves a dual purpose of setting up state and + # providing a memoized reference to that state. + # + # @example + # + # class Thing + # def self.count + # @count ||= 0 + # end + # + # def self.count=(val) + # @count += val + # end + # + # def self.reset_count + # @count = 0 + # end + # + # def initialize + # self.class.count += 1 + # end + # end + # + # RSpec.describe Thing do + # after(:example) { Thing.reset_count } + # + # context "using subject" do + # subject { Thing.new } + # + # it "is not invoked implicitly" do + # Thing.count.should eq(0) + # end + # + # it "can be invoked explicitly" do + # subject + # Thing.count.should eq(1) + # end + # end + # + # context "using subject!" do + # subject!(:thing) { Thing.new } + # + # it "is invoked implicitly" do + # Thing.count.should eq(1) + # end + # + # it "returns memoized version on first invocation" do + # subject + # Thing.count.should eq(1) + # end + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:510 + def subject!(name = T.unsafe(nil), &block); end +end + +# Used internally to customize the behavior of the +# memoized hash when used in a `before(:context)` hook. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:200 +class RSpec::Core::MemoizedHelpers::ContextHookMemoized + class << self + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:222 + def fetch_or_store(key, &_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:201 + def isolate_for_context_hook(example_group_instance); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:256 +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized + class << self + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:261 + def article; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:257 + def hook_expression; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:265 + def hook_intention; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:241 +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized + class << self + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:246 + def article; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:242 + def hook_expression; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:250 + def hook_intention; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:186 +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized + # @return [NonThreadSafeMemoized] a new instance of NonThreadSafeMemoized + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:187 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:191 + def fetch_or_store(key); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:170 +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized + # @return [ThreadsafeMemoized] a new instance of ThreadsafeMemoized + # + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:171 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/memoized_helpers.rb:176 + def fetch_or_store(key); end +end + +# Each ExampleGroup class and Example instance owns an instance of +# Metadata, which is Hash extended to support lazy evaluation of values +# associated with keys that may or may not be used by any example or group. +# +# In addition to metadata that is used internally, this also stores +# user-supplied metadata, e.g. +# +# RSpec.describe Something, :type => :ui do +# it "does something", :slow => true do +# # ... +# end +# end +# +# `:type => :ui` is stored in the Metadata owned by the example group, and +# `:slow => true` is stored in the Metadata owned by the example. These can +# then be used to select which examples are run using the `--tag` option on +# the command line, or several methods on `Configuration` used to filter a +# run (e.g. `filter_run_including`, `filter_run_excluding`, etc). +# +# @see Example#metadata +# @see ExampleGroup.metadata +# @see FilterManager +# @see Configuration#filter_run_including +# @see Configuration#filter_run_excluding +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:27 +module RSpec::Core::Metadata + class << self + # Returns an enumerator that iteratively walks up the given metadata through all + # example group ancestors, yielding each metadata hash along the way. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:71 + def ascend(metadata); end + + # Iteratively walks up from the given metadata through all + # example group ancestors, yielding each metadata hash along the way. + # + # @private + # @yield [metadata] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:58 + def ascending(metadata); end + + # Used internally to build a hash from an args array. + # Symbols are converted into hash keys with a value of `true`. + # This is done to support simple tagging using a symbol, rather + # than needing to do `:symbol => true`. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:80 + def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:94 + def deep_hash_dup(object); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:105 + def id_from(metadata); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:110 + def location_tuple_from(metadata); end + + # @api private + # @param line [String] current code line + # @return [String] relative path to line + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:44 + def relative_path(line); end + + # Matches strings either at the beginning of the input or prefixed with a + # whitespace, containing the current path, either postfixed with the + # separator, or at the end of the string. Match groups are the character + # before and the character after the string if any. + # + # http://rubular.com/r/fT0gmX6VJX + # http://rubular.com/r/duOrD4i3wb + # http://rubular.com/r/sbAMHFrOx1 + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:36 + def relative_path_regex; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:247 +class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator + private + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:304 + def described_class; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:311 + def full_description; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:265 + def backwards_compatibility_default_proc(&example_group_selector); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:248 + def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:261 + def hash_with_backwards_compatibility_default_proc; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:213 +class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator + private + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:234 + def described_class; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:238 + def full_description; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:214 + def create(group_metadata, user_metadata, index_provider, description, block); end + end +end + +# Used internally to populate metadata hashes with computed keys +# managed by RSpec. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:117 +class RSpec::Core::Metadata::HashPopulator + # @return [HashPopulator] a new instance of HashPopulator + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:120 + def initialize(metadata, user_metadata, index_provider, description_args, block); end + + # Returns the value of attribute block. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:118 + def block; end + + # Returns the value of attribute description_args. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:118 + def description_args; end + + # Returns the value of attribute metadata. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:118 + def metadata; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:128 + def populate; end + + # Returns the value of attribute user_metadata. + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:118 + def user_metadata; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:178 + def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:185 + def build_scoped_id_for(file_path); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:170 + def description_separator(parent_part, child_part); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:191 + def ensure_valid_user_keys; end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:164 + def file_path_and_line_number_from(backtrace); end + + # source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:143 + def populate_location_attributes; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata.rb:325 +RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array) + +# Contains metadata filtering logic. This has been extracted from +# the metadata classes because it operates ON a metadata hash but +# does not manage any of the state in the hash. We're moving towards +# having metadata be a raw hash (not a custom subclass), so externalizing +# this filtering logic helps us move in that direction. +# +# source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:8 +module RSpec::Core::MetadataFilter + class << self + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:11 + def apply?(predicate, filters, metadata); end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:16 + def filter_applies?(key, filter_value, metadata); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:33 + def silence_metadata_example_group_deprecations; end + + private + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:42 + def filter_applies_to_any_value?(key, value, metadata); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:73 + def filters_apply?(key, value, metadata); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:46 + def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:54 + def location_filter_applies?(locations, metadata); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/metadata_filter.rb:65 + def proc_filter_applies?(key, proc, metadata); end + end +end + +# Provides a single exception instance that provides access to +# multiple sub-exceptions. This is used in situations where a single +# individual spec has multiple exceptions, such as one in the `it` block +# and one in an `after` block. +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:432 +class RSpec::Core::MultipleExceptionError < ::StandardError + include ::RSpec::Core::MultipleExceptionError::InterfaceTag + + # @param exceptions [Array<Exception>] The initial list of exceptions. + # @return [MultipleExceptionError] a new instance of MultipleExceptionError + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:488 + def initialize(*exceptions); end + + # @return [nil] Provided only for interface compatibility with + # `RSpec::Expectations::MultipleExpectationsNotMetError`. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:485 + def aggregation_block_label; end + + # @return [Hash] Metadata used by RSpec for formatting purposes. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:481 + def aggregation_metadata; end + + # @return [Array<Exception>] The list of failures and other exceptions, combined. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:478 + def all_exceptions; end + + # return [String] A description of the failure/error counts. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:513 + def exception_count_description; end + + # @return [Array<Exception>] The list of failures. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:472 + def failures; end + + # @note RSpec does not actually use this -- instead it formats each exception + # individually. + # @return [String] Combines all the exception messages into a single string. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:503 + def message; end + + # @return [Array<Exception>] The list of other errors. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:475 + def other_errors; end + + # @return [String] A summary of the failure, including the block label and a count of failures. + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:508 + def summary; end +end + +# Used so there is a common module in the ancestor chain of this class +# and `RSpec::Expectations::MultipleExpectationsNotMetError`, which allows +# code to detect exceptions that are instances of either, without first +# checking to see if rspec-expectations is loaded. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:433 +module RSpec::Core::MultipleExceptionError::InterfaceTag + # Appends the provided exception to the list. + # + # @param exception [Exception] Exception to append to the list. + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:437 + def add(exception); end + + class << self + # Provides a way to force `ex` to be something that satisfies the multiple + # exception error interface. If it already satisfies it, it will be returned; + # otherwise it will wrap it in a `MultipleExceptionError`. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/formatters/exception_presenter.rb:463 + def for(ex); end + end +end + +# Notifications are value objects passed to formatters to provide them +# with information about a particular event of interest. +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:9 +module RSpec::Core::Notifications; end + +# `CustomNotification` is used when sending custom events to formatters / +# other registered listeners, it creates attributes based on supplied hash +# of options. +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:514 +class RSpec::Core::Notifications::CustomNotification < ::Struct + class << self + # Build a custom notification based on the supplied option key / values. + # + # @param options [Hash] A hash of method / value pairs to create on this notification + # @return [CustomNotification] + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:515 + def for(options = T.unsafe(nil)); end + end +end + +# The `DeprecationNotification` is issued by the reporter when a deprecated +# part of RSpec is encountered. It represents information about the +# deprecated call site. +# +# @attr message [String] A custom message about the deprecation +# @attr deprecated [String] A custom message about the deprecation (alias of +# message) +# @attr replacement [String] An optional replacement for the deprecation +# @attr call_site [String] An optional call site from which the deprecation +# was issued +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:491 +class RSpec::Core::Notifications::DeprecationNotification < ::Struct + # An optional call site from which the deprecation + # was issued + # + # @return [String] the current value of call_site + def call_site; end + + # An optional call site from which the deprecation + # was issued + # + # @param value [String] the value to set the attribute call_site to. + # @return [String] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:491 + def call_site=(_); end + + # A custom message about the deprecation (alias of + # message) + # + # @return [String] the current value of deprecated + def deprecated; end + + # A custom message about the deprecation (alias of + # message) + # + # @param value [String] the value to set the attribute deprecated to. + # @return [String] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:491 + def deprecated=(_); end + + # A custom message about the deprecation + # + # @return [String] the current value of message + def message; end + + # A custom message about the deprecation + # + # @param value [String] the value to set the attribute message to. + # @return [String] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:491 + def message=(_); end + + # An optional replacement for the deprecation + # + # @return [String] the current value of replacement + def replacement; end + + # An optional replacement for the deprecation + # + # @param value [String] the value to set the attribute replacement to. + # @return [String] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:491 + def replacement=(_); end + + class << self + def [](*_arg0); end + + # Convenience way to initialize the notification + # + # @api + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:497 + def from_hash(data); end + + def inspect; end + def members; end + + private + + def new(*_arg0); end + end +end + +# The `ExampleNotification` represents notifications sent by the reporter +# which contain information about the current (or soon to be) example. +# It is used by formatters to access information about that example. +# +# @attr example [RSpec::Core::Example] the current example +# @example +# def example_started(notification) +# puts "Hey I started #{notification.example.description}" +# end +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:38 +class RSpec::Core::Notifications::ExampleNotification < ::Struct + # the current example + # + # @return [RSpec::Core::Example] the current value of example + def example; end + + # the current example + # + # @param value [RSpec::Core::Example] the value to set the attribute example to. + # @return [RSpec::Core::Example] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:38 + def example=(_); end + + class << self + def [](*_arg0); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:41 + def for(example); end + + def inspect; end + def members; end + + private + + def new(*_arg0); end + end +end + +# The `ExamplesNotification` represents notifications sent by the reporter +# which contain information about the suites examples. +# +# @example +# def stop(notification) +# puts "Hey I ran #{notification.examples.size}" +# end +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:69 +class RSpec::Core::Notifications::ExamplesNotification + # @return [ExamplesNotification] a new instance of ExamplesNotification + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:70 + def initialize(reporter); end + + # @return [Array<RSpec::Core::Example>] list of examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:75 + def examples; end + + # @return [Array<RSpec::Core::Example>] list of failed examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:80 + def failed_examples; end + + # @return [Array<RSpec::Core::Notifications::FailedExampleNotification>] returns failed examples as notifications + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:97 + def failure_notifications; end + + # @return [String] The list of failed examples, fully formatted in the way + # that RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:110 + def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end + + # @return [String] The list of pending examples, fully formatted in the + # way that RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:122 + def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end + + # @return [Array<RSpec::Core::Notifications::ExampleNotification>] returns examples as notifications + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:91 + def notifications; end + + # @return [Array<RSpec::Core::Example>] list of pending examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:85 + def pending_examples; end + + # returns pending examples as notifications + # + # @return [Array<RSpec::Core::Notifications::SkippedExampleNotification, + # RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification>] + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:104 + def pending_notifications; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:134 + def format_examples(examples); end +end + +# The `FailedExampleNotification` extends `ExampleNotification` with +# things useful for examples that have failure info -- typically a +# failed or pending spec. +# +# @attr example [RSpec::Core::Example] the current example +# @example +# def example_failed(notification) +# puts "Hey I failed :(" +# puts "Here's my stack trace" +# puts notification.exception.backtrace.join("\n") +# end +# @see ExampleNotification +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:154 +class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification + # @return [FailedExampleNotification] a new instance of FailedExampleNotification + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:211 + def initialize(example, exception_presenter = T.unsafe(nil)); end + + # Returns the failures colorized formatted backtrace. + # + # @param colorizer [#wrap] An object to colorize the message_lines by + # @return [Array<String>] the examples colorized backtrace lines + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:193 + def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end + + # Returns the message generated for this failure colorized line by line. + # + # @param colorizer [#wrap] An object to colorize the message_lines by + # @return [Array<String>] The example failure message colorized + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:178 + def colorized_message_lines(colorizer = T.unsafe(nil)); end + + # @return [String] The example description + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:163 + def description; end + + # @return [Exception] The example failure + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:158 + def exception; end + + # Returns the failures formatted backtrace. + # + # @return [Array<String>] the examples backtrace lines + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:185 + def formatted_backtrace; end + + # @return [String] The failure information fully formatted in the way that + # RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:199 + def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end + + # @return [Array<string>] The failure information fully formatted in the way that + # RSpec's built-in formatters emit, split by line. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:205 + def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end + + # Returns the message generated for this failure line by line. + # + # @return [Array<String>] The example failure message + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:170 + def message_lines; end +end + +# The `GroupNotification` represents notifications sent by the reporter +# which contain information about the currently running (or soon to be) +# example group. It is used by formatters to access information about that +# group. +# +# @attr group [RSpec::Core::ExampleGroup] the current group +# @example +# def example_group_started(notification) +# puts "Hey I started #{notification.group.description}" +# end +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:256 +class RSpec::Core::Notifications::GroupNotification < ::Struct + # the current group + # + # @return [RSpec::Core::ExampleGroup] the current value of group + def group; end + + # the current group + # + # @param value [RSpec::Core::ExampleGroup] the value to set the attribute group to. + # @return [RSpec::Core::ExampleGroup] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:256 + def group=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# The `MessageNotification` encapsulates generic messages that the reporter +# sends to formatters. +# +# @attr message [String] the message +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:262 +class RSpec::Core::Notifications::MessageNotification < ::Struct + # the message + # + # @return [String] the current value of message + def message; end + + # the message + # + # @param value [String] the value to set the attribute message to. + # @return [String] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:262 + def message=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:11 +module RSpec::Core::Notifications::NullColorizer + private + + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:14 + def wrap(line, _code_or_symbol); end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:14 + def wrap(line, _code_or_symbol); end + end +end + +# `NullNotification` represents a placeholder value for notifications that +# currently require no information, but we may wish to extend in future. +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:504 +class RSpec::Core::Notifications::NullNotification; end + +# @deprecated Use {FailedExampleNotification} instead. +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:221 +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end + +# @deprecated Use {FailedExampleNotification} instead. +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:218 +class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end + +# The `ProfileNotification` holds information about the results of running a +# test suite when profiling is enabled. It is used by formatters to provide +# information at the end of the test run for profiling information. +# +# @attr duration [Float] the time taken (in seconds) to run the suite +# @attr examples [Array<RSpec::Core::Example>] the examples run +# @attr number_of_examples [Fixnum] the number of examples to profile +# @attr example_groups [Array<RSpec::Core::Profiler>] example groups run +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:427 +class RSpec::Core::Notifications::ProfileNotification + # @return [ProfileNotification] a new instance of ProfileNotification + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:428 + def initialize(duration, examples, number_of_examples, example_groups); end + + # the time taken (in seconds) to run the suite + # + # @return [Float] the current value of duration + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:434 + def duration; end + + # the examples run + # + # @return [Array<RSpec::Core::Example>] the current value of examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:434 + def examples; end + + # the number of examples to profile + # + # @return [Fixnum] the current value of number_of_examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:434 + def number_of_examples; end + + # @return [String] the percentage of total time taken + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:453 + def percentage; end + + # @return [Float] the time taken (in seconds) to run the slowest examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:445 + def slow_duration; end + + # @return [Array<RSpec::Core::Example>] the slowest examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:437 + def slowest_examples; end + + # @return [Array<RSpec::Core::Example>] the slowest example groups + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:462 + def slowest_groups; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:468 + def calculate_slowest_groups; end +end + +# The `SeedNotification` holds the seed used to randomize examples and +# whether that seed has been used or not. +# +# @attr seed [Fixnum] the seed used to randomize ordering +# @attr used [Boolean] whether the seed has been used or not +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:269 +class RSpec::Core::Notifications::SeedNotification < ::Struct + # @return [String] The seed information fully formatted in the way that + # RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:280 + def fully_formatted; end + + # the seed used to randomize ordering + # + # @return [Fixnum] the current value of seed + def seed; end + + # the seed used to randomize ordering + # + # @param value [Fixnum] the value to set the attribute seed to. + # @return [Fixnum] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:269 + def seed=(_); end + + # @api + # @return [Boolean] has the seed been used? + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:273 + def seed_used?; end + + # whether the seed has been used or not + # + # @param value [Boolean] the value to set the attribute used to. + # @return [Boolean] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:269 + def used=(_); end + + private + + # whether the seed has been used or not + # + # @return [Boolean] the current value of used + def used; end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# The `SkippedExampleNotification` extends `ExampleNotification` with +# things useful for specs that are skipped. +# +# @attr example [RSpec::Core::Example] the current example +# @see ExampleNotification +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:228 +class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification + # @return [String] The pending detail fully formatted in the way that + # RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:233 + def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end +end + +# The `StartNotification` represents a notification sent by the reporter +# when the suite is started. It contains the expected amount of examples +# to be executed, and the load time of RSpec. +# +# @attr count [Fixnum] the number counted +# @attr load_time [Float] the number of seconds taken to boot RSpec +# and load the spec files +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:26 +class RSpec::Core::Notifications::StartNotification < ::Struct + # the number counted + # + # @return [Fixnum] the current value of count + def count; end + + # the number counted + # + # @param value [Fixnum] the value to set the attribute count to. + # @return [Fixnum] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:26 + def count=(_); end + + # the number of seconds taken to boot RSpec + # and load the spec files + # + # @return [Float] the current value of load_time + def load_time; end + + # the number of seconds taken to boot RSpec + # and load the spec files + # + # @param value [Float] the value to set the attribute load_time to. + # @return [Float] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:26 + def load_time=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# The `SummaryNotification` holds information about the results of running +# a test suite. It is used by formatters to provide information at the end +# of the test run. +# +# @attr duration [Float] the time taken (in seconds) to run the suite +# @attr examples [Array<RSpec::Core::Example>] the examples run +# @attr failed_examples [Array<RSpec::Core::Example>] the failed examples +# @attr pending_examples [Array<RSpec::Core::Example>] the pending examples +# @attr load_time [Float] the number of seconds taken to boot RSpec +# and load the spec files +# @attr errors_outside_of_examples_count [Integer] the number of errors that +# have occurred processing +# the spec suite +# +# source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 +class RSpec::Core::Notifications::SummaryNotification < ::Struct + include ::RSpec::Core::ShellEscape + + # Formats failures into a rerunable command format. + # + # @api public + # @param colorizer [#wrap] An object which supports wrapping text with + # specific colors. + # @return [String] A colorized summary line. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:362 + def colorized_rerun_commands(colorizer = T.unsafe(nil)); end + + # Wraps the results line with colors based on the configured + # colors for failure, pending, and success. Defaults to red, + # yellow, green accordingly. + # + # @api public + # @param colorizer [#wrap] An object which supports wrapping text with + # specific colors. + # @return [String] A colorized results line. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:345 + def colorized_totals_line(colorizer = T.unsafe(nil)); end + + # the time taken (in seconds) to run the suite + # + # @return [Float] the current value of duration + def duration; end + + # the time taken (in seconds) to run the suite + # + # @param value [Float] the value to set the attribute duration to. + # @return [Float] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def duration=(_); end + + # the number of errors that + # have occurred processing + # the spec suite + # + # @return [Integer] the current value of errors_outside_of_examples_count + def errors_outside_of_examples_count; end + + # the number of errors that + # have occurred processing + # the spec suite + # + # @param value [Integer] the value to set the attribute errors_outside_of_examples_count to. + # @return [Integer] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def errors_outside_of_examples_count=(_); end + + # @api + # @return [Fixnum] the number of examples run + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:304 + def example_count; end + + # the examples run + # + # @return [Array<RSpec::Core::Example>] the current value of examples + def examples; end + + # the examples run + # + # @param value [Array<RSpec::Core::Example>] the value to set the attribute examples to. + # @return [Array<RSpec::Core::Example>] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def examples=(_); end + + # the failed examples + # + # @return [Array<RSpec::Core::Example>] the current value of failed_examples + def failed_examples; end + + # the failed examples + # + # @param value [Array<RSpec::Core::Example>] the value to set the attribute failed_examples to. + # @return [Array<RSpec::Core::Example>] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def failed_examples=(_); end + + # @api + # @return [Fixnum] the number of failed examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:310 + def failure_count; end + + # @return [String] a formatted version of the time it took to run the + # suite + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:372 + def formatted_duration; end + + # @return [String] a formatted version of the time it took to boot RSpec + # and load the spec files + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:378 + def formatted_load_time; end + + # @return [String] The summary information fully formatted in the way that + # RSpec's built-in formatters emit. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:384 + def fully_formatted(colorizer = T.unsafe(nil)); end + + # the number of seconds taken to boot RSpec + # and load the spec files + # + # @return [Float] the current value of load_time + def load_time; end + + # the number of seconds taken to boot RSpec + # and load the spec files + # + # @param value [Float] the value to set the attribute load_time to. + # @return [Float] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def load_time=(_); end + + # @api + # @return [Fixnum] the number of pending examples + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:316 + def pending_count; end + + # the pending examples + # + # @return [Array<RSpec::Core::Example>] the current value of pending_examples + def pending_examples; end + + # the pending examples + # + # @param value [Array<RSpec::Core::Example>] the value to set the attribute pending_examples to. + # @return [Array<RSpec::Core::Example>] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:298 + def pending_examples=(_); end + + # @api + # @return [String] A line summarising the result totals of the spec run. + # + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:322 + def totals_line; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:406 + def duplicate_rerun_locations; end + + # source://rspec-core-3.11.0/lib/rspec/core/notifications.rb:400 + def rerun_argument_for(example); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# # Used in place of a {Reporter} for situations where we don't want reporting output. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:259 +class RSpec::Core::NullReporter + class << self + private + + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:260 + def method_missing(*_arg0); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:4 +module RSpec::Core::Ordering; end + +# Manages ordering configuration. +# +# @note This is not intended to be used externally. Use +# the APIs provided by `RSpec::Core::Configuration` instead. +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:116 +class RSpec::Core::Ordering::ConfigurationManager + # @return [ConfigurationManager] a new instance of ConfigurationManager + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:119 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:151 + def force(hash); end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:136 + def order=(type); end + + # Returns the value of attribute ordering_registry. + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:117 + def ordering_registry; end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:162 + def register_ordering(name, strategy = T.unsafe(nil)); end + + # Returns the value of attribute seed. + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:117 + def seed; end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:130 + def seed=(seed); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:126 + def seed_used?; end +end + +# Orders items based on a custom block. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:71 +class RSpec::Core::Ordering::Custom + # @return [Custom] a new instance of Custom + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:72 + def initialize(callable); end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:76 + def order(list); end +end + +# The default global ordering (defined order). +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:7 +class RSpec::Core::Ordering::Identity + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:8 + def order(items); end +end + +# Orders items randomly. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:15 +class RSpec::Core::Ordering::Random + # @return [Random] a new instance of Random + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:16 + def initialize(configuration); end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:25 + def order(items); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:21 + def used?; end + + private + + # http://en.wikipedia.org/wiki/Jenkins_hash_function + # Jenkins provides a good distribution and is simpler than MD5. + # It's a bit slower than MD5 (primarily because `Digest::MD5` is + # implemented in C) but has the advantage of not requiring us + # to load another part of stdlib, which we try to minimize. + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:39 + def jenkins_hash_digest(string); end +end + +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:58 +RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer) + +# Orders items by modification time (most recent modified first). +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:63 +class RSpec::Core::Ordering::RecentlyModified + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:64 + def order(list); end +end + +# Stores the different ordering strategies. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:83 +class RSpec::Core::Ordering::Registry + # @return [Registry] a new instance of Registry + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:84 + def initialize(configuration); end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:98 + def fetch(name, &fallback); end + + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:102 + def register(sym, strategy); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/ordering.rb:106 + def used_random_seed?; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:4 +class RSpec::Core::OutputWrapper + # @private + # @return [OutputWrapper] a new instance of OutputWrapper + # + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:9 + def initialize(output); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def <<(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def advise(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def autoclose=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def autoclose?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def binmode(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def binmode?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def bytes(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def chars(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def close(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def close_on_exec=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def close_on_exec?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def close_read(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def close_write(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def closed?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def codepoints(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def each(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def each_byte(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def each_char(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def each_codepoint(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def each_line(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def eof(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def eof?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def external_encoding(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def fcntl(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def fdatasync(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def fileno(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def flush(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def fsync(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def getbyte(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def getc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def gets(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def inspect(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def internal_encoding(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def ioctl(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def isatty(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def lineno(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def lineno=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def lines(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:17 + def method_missing(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def nread(*args, &block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:6 + def output; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:6 + def output=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pathconf(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pid(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pos(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pos=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pread(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def print(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def printf(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def putc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def puts(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def pwrite(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def read(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def read_nonblock(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def readbyte(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def readchar(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def readline(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def readlines(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def readpartial(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def ready?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def reopen(*args, &block); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:13 + def respond_to?(name, priv = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def rewind(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def seek(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def set_encoding(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def set_encoding_by_bom(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def stat(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def sync(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def sync=(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def sysread(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def sysseek(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def syswrite(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def tell(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def to_i(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def to_io(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def tty?(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def ungetbyte(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def ungetc(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def wait(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def wait_readable(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def wait_writable(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def write(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/output_wrapper.rb:23 + def write_nonblock(*args, &block); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:6 +class RSpec::Core::Parser + # @return [Parser] a new instance of Parser + # + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:13 + def initialize(original_args); end + + # Returns the value of attribute original_args. + # + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:11 + def original_args; end + + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:17 + def parse(source = T.unsafe(nil)); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:312 + def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:320 + def configure_only_failures(options); end + + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:40 + def parser(options); end + + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:316 + def set_fail_fast(options, value); end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/option_parser.rb:7 + def parse(args, source = T.unsafe(nil)); end + end +end + +# Provides methods to mark examples as pending. These methods are available +# to be called from within any example or hook. +# +# source://rspec-core-3.11.0/lib/rspec/core/pending.rb:5 +module RSpec::Core::Pending + # Marks an example as pending. The rest of the example will still be + # executed, and if it passes the example will fail to indicate that the + # pending can be removed. + # + # @example + # describe "some behaviour" do + # # reported as "Pending: no reason given" + # it "is pending with no message" do + # pending + # raise "broken" + # end + # + # # reported as "Pending: something else getting finished" + # it "is pending with a custom message" do + # pending("something else getting finished") + # raise "broken" + # end + # end + # @note When using `pending` inside an example body using this method + # hooks, such as `before(:example)`, have already be run. This means that + # a failure from the code in the `before` hook will prevent the example + # from being considered pending, as the example body would not be + # executed. If you need to consider hooks as pending as well you can use + # the pending metadata as an alternative, e.g. + # `it "does something", pending: "message"`. + # @overload pending + # @overload pending + # @param message [String] optional message to add to the summary report. + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:62 + def pending(message = T.unsafe(nil)); end + + # Marks an example as pending and skips execution. + # + # @example + # describe "an example" do + # # reported as "Pending: no reason given" + # it "is skipped with no message" do + # skip + # end + # + # # reported as "Pending: something else getting finished" + # it "is skipped with a custom message" do + # skip "something else getting finished" + # end + # end + # @overload skip + # @overload skip + # @param message [String] optional message to add to the summary report. + # @raise [SkipDeclaredInExample] + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:110 + def skip(message = T.unsafe(nil)); end + + class << self + # Mark example as fixed. + # + # @param example [RSpec::Core::Example] the example to mark as fixed + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:152 + def mark_fixed!(example); end + + # Mark example as pending. + # + # @param example [RSpec::Core::Example] the example to mark as pending + # @param message_or_bool [Boolean, String] the message to use, or true + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:135 + def mark_pending!(example, message_or_bool); end + + # Mark example as skipped. + # + # @param example [RSpec::Core::Example] the example to mark as skipped + # @param message_or_bool [Boolean, String] the message to use, or true + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:124 + def mark_skipped!(example, message_or_bool); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/pending.rb:29 +RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/pending.rb:26 +RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String) + +# source://rspec-core-3.11.0/lib/rspec/core/pending.rb:22 +class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError; end + +# Raised in the middle of an example to indicate that it should be marked +# as skipped. +# +# source://rspec-core-3.11.0/lib/rspec/core/pending.rb:8 +class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError + # @return [SkipDeclaredInExample] a new instance of SkipDeclaredInExample + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:11 + def initialize(argument); end + + # Returns the value of attribute argument. + # + # source://rspec-core-3.11.0/lib/rspec/core/pending.rb:9 + def argument; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:4 +class RSpec::Core::Profiler + # @return [Profiler] a new instance of Profiler + # + # source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:7 + def initialize; end + + # source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:20 + def example_group_finished(notification); end + + # source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:13 + def example_group_started(notification); end + + # Returns the value of attribute example_groups. + # + # source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:11 + def example_groups; end + + # source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:28 + def example_started(notification); end +end + +# source://rspec-core-3.11.0/lib/rspec/core/profiler.rb:5 +RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array) + +# RSpec rake task +# +# @see Rakefile +# +# source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:20 +class RSpec::Core::RakeTask < ::Rake::TaskLib + include ::RSpec::Core::ShellEscape + + # @return [RakeTask] a new instance of RakeTask + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:77 + def initialize(*args, &task_block); end + + # Files matching this pattern will be excluded. + # Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:39 + def exclude_pattern; end + + # Files matching this pattern will be excluded. + # Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:39 + def exclude_pattern=(_arg0); end + + # Whether or not to fail Rake when an error occurs (typically when + # examples fail). Defaults to `true`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:43 + def fail_on_error; end + + # Whether or not to fail Rake when an error occurs (typically when + # examples fail). Defaults to `true`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:43 + def fail_on_error=(_arg0); end + + # A message to print to stderr when there are failures. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:46 + def failure_message; end + + # A message to print to stderr when there are failures. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:46 + def failure_message=(_arg0); end + + # Name of task. Defaults to `:spec`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:31 + def name; end + + # Name of task. Defaults to `:spec`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:31 + def name=(_arg0); end + + # Files matching this pattern will be loaded. + # Defaults to `'spec/**{,/*/**}/*_spec.rb'`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:35 + def pattern; end + + # Files matching this pattern will be loaded. + # Defaults to `'spec/**{,/*/**}/*_spec.rb'`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:35 + def pattern=(_arg0); end + + # Command line options to pass to RSpec. Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:75 + def rspec_opts; end + + # Command line options to pass to RSpec. Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:75 + def rspec_opts=(_arg0); end + + # Path to RSpec. Defaults to the absolute path to the + # rspec binary from the loaded rspec-core gem. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:72 + def rspec_path; end + + # Path to RSpec. Defaults to the absolute path to the + # rspec binary from the loaded rspec-core gem. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:72 + def rspec_path=(_arg0); end + + # Command line options to pass to ruby. Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:68 + def ruby_opts; end + + # Command line options to pass to ruby. Defaults to `nil`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:68 + def ruby_opts=(_arg0); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:90 + def run_task(verbose); end + + # Use verbose output. If this is set to true, the task will print the + # executed spec command to stdout. Defaults to `true`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:65 + def verbose; end + + # Use verbose output. If this is set to true, the task will print the + # executed spec command to stdout. Defaults to `true`. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:65 + def verbose=(_arg0); end + + # Run RSpec with a clean (empty) environment. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:60 + def with_clean_environment; end + + # Run RSpec with a clean (empty) environment. + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:60 + def with_clean_environment=(_arg0); end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:173 + def blank; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:110 + def define(args, &task_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:157 + def file_exclusion_specification; end + + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:121 + def file_inclusion_specification; end + + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:177 + def rspec_load_path; end + + # source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:161 + def spec_command; end +end + +# Default pattern for spec files. +# +# source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:28 +RSpec::Core::RakeTask::DEFAULT_PATTERN = T.let(T.unsafe(nil), String) + +# Default path to the RSpec executable. +# +# source://rspec-core-3.11.0/lib/rspec/core/rake_task.rb:25 +RSpec::Core::RakeTask::DEFAULT_RSPEC_PATH = T.let(T.unsafe(nil), String) + +# A reporter will send notifications to listeners, usually formatters for the +# spec suite run. +# +# source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:4 +class RSpec::Core::Reporter + # @return [Reporter] a new instance of Reporter + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:14 + def initialize(configuration); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:214 + def abort_with(msg, exit_status); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:193 + def close_after; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:155 + def deprecation(hash); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:143 + def example_failed(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:133 + def example_finished(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:122 + def example_group_finished(group); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:117 + def example_group_started(group); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:138 + def example_passed(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:149 + def example_pending(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:127 + def example_started(example); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:28 + def examples; end + + # Reports a run that exited early without having run any examples. + # + # @param exit_code [Integer] the exit_code to be return by the reporter + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:84 + def exit_early(exit_code); end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:221 + def fail_fast_limit_met?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:28 + def failed_examples; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:173 + def finish; end + + # Send a custom message to supporting formatters. + # + # @param message [#to_s] A message object to send to formatters + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:99 + def message(message); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:206 + def notify(event, notification); end + + # Provides a way to notify of an exception that is not tied to any + # particular example (such as an exception encountered in a :suite hook). + # Exceptions will be formatted the same way they normally are. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:163 + def notify_non_example_exception(exception, context_description); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:28 + def pending_examples; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:45 + def prepare_default(loader, output_stream, deprecation_stream); end + + # Publish a custom event to supporting registered formatters. + # + # @param event [Symbol] Name of the custom event to trigger on formatters + # @param options [Hash] Hash of arguments to provide via `CustomNotification` + # @see RSpec::Core::Notifications::CustomNotification + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:108 + def publish(event, options = T.unsafe(nil)); end + + # Registers a listener to a list of notifications. The reporter will send + # notification of events to all registered listeners. + # + # @param listener [Object] An obect that wishes to be notified of reporter + # events + # @param notifications [Array] Array of symbols represents the events a + # listener wishes to subscribe too + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:37 + def register_listener(listener, *notifications); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:52 + def registered_listeners(notification); end + + # Initializes the report run and yields itself for further reporting. The + # block is required, so that the reporter can manage cleaning up after the + # run. + # + # @example + # + # reporter.report(group.examples.size) do |r| + # example_groups.map {|g| g.run(r) } + # end + # @overload report + # @overload report + # @param expected_example_count [Integer] the number of examples being run + # @yield [Block] block yields itself for further reporting. + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:71 + def report(expected_example_count); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:89 + def start(expected_example_count, time = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:200 + def stop; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:242 + def close; end + + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:233 + def ensure_listeners_ready; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:246 + def mute_profile_output?; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:252 + def seed_used?; end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/reporter.rb:6 +RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:7 +module RSpec::Core::RubyProject + private + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:12 + def add_dir_to_load_path(dir); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:8 + def add_to_load_path(*dirs); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:28 + def ascend_until; end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:20 + def determine_root; end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:24 + def find_first_parent_containing(dir); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:16 + def root; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:12 + def add_dir_to_load_path(dir); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:8 + def add_to_load_path(*dirs); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:28 + def ascend_until; end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:20 + def determine_root; end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:24 + def find_first_parent_containing(dir); end + + # source://rspec-core-3.11.0/lib/rspec/core/ruby_project.rb:16 + def root; end + end +end + +# Provides the main entry point to run a suite of RSpec examples. +# +# source://rspec-core-3.11.0/lib/rspec/core/runner.rb:4 +class RSpec::Core::Runner + # @return [Runner] a new instance of Runner + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:75 + def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end + + # @attr_reader + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:7 + def configuration; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:129 + def configure(err, out); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:190 + def exit_code(examples_passed = T.unsafe(nil)); end + + # @attr_reader + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:7 + def options; end + + # Configures and runs a spec suite. + # + # @param err [IO] error stream + # @param out [IO] output stream + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:85 + def run(err, out); end + + # Runs the provided example groups. + # + # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run + # @return [Fixnum] exit status code. 0 if all specs passed, + # or the configured failure exit code (1 by default) if specs + # failed. + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:113 + def run_specs(example_groups); end + + # Wires together the various configuration objects and state holders. + # + # @param err [IO] error stream + # @param out [IO] output stream + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:98 + def setup(err, out); end + + # @attr_reader + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:7 + def world; end + + private + + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:199 + def persist_example_statuses; end + + class << self + # Register an `at_exit` hook that runs the suite when the process exits. + # + # @note This is not generally needed. The `rspec` command takes care + # of running examples for you without involving an `at_exit` + # hook. This is only needed if you are running specs using + # the `ruby` command, and even then, the normal way to invoke + # this is by requiring `rspec/autorun`. + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:16 + def autorun; end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:141 + def autorun_disabled?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:136 + def disable_autorun!; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:180 + def handle_interrupt; end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:146 + def installed_at_exit?; end + + # Runs the suite of specs and exits the process with an appropriate exit + # code. + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:43 + def invoke; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:29 + def perform_at_exit; end + + # Run a suite of RSpec examples. Does not exit. + # + # This is used internally by RSpec to run a suite, but is available + # for use by any other automation tool. + # + # If you want to run this multiple times in the same process, and you + # want files like `spec_helper.rb` to be reloaded, be sure to load `load` + # instead of `require`. + # + # @param args [Array] command-line-supported arguments + # @param err [IO] error stream + # @param out [IO] output stream + # @return [Fixnum] exit status code. 0 if all specs passed, + # or the configured failure exit code (1 by default) if specs + # failed. + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:64 + def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end + + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:151 + def running_in_drb?; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/runner.rb:175 + def trap_interrupt; end + end +end + +# We use this to replace `::Set` so we can have the advantage of +# constant time key lookups for unique arrays but without the +# potential to pollute a developers environment with an extra +# piece of the stdlib. This helps to prevent false positive +# builds. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/set.rb:11 +class RSpec::Core::Set + include ::Enumerable + + # @return [Set] a new instance of Set + # + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:14 + def initialize(array = T.unsafe(nil)); end + + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:23 + def <<(key); end + + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:48 + def clear; end + + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:28 + def delete(key); end + + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:32 + def each(&block); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:19 + def empty?; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:37 + def include?(key); end + + # source://rspec-core-3.11.0/lib/rspec/core/set.rb:41 + def merge(values); end +end + +# Exposes {ExampleGroup}-level methods to a module, so you can include that +# module in an {ExampleGroup}. +# +# @example +# +# module LoggedInAsAdmin +# extend RSpec::Core::SharedContext +# before(:example) do +# log_in_as :admin +# end +# end +# +# describe "admin section" do +# include LoggedInAsAdmin +# # ... +# end +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:19 +module RSpec::Core::SharedContext + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:28 + def __shared_context_recordings; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def after(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def append_after(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def append_before(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def around(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def before(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def context(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def describe(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def hooks(*args, &block); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:21 + def included(group); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def let(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def let!(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def prepend_after(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def prepend_before(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def subject(*args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:42 + def subject!(*args, &block); end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:40 + def record(methods); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:33 +class RSpec::Core::SharedContext::Recording < ::Struct + # Returns the value of attribute args + # + # @return [Object] the current value of args + def args; end + + # Sets the attribute args + # + # @param value [Object] the value to set the attribute args to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:33 + def args=(_); end + + # Returns the value of attribute block + # + # @return [Object] the current value of block + def block; end + + # Sets the attribute block + # + # @param value [Object] the value to set the attribute block to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:33 + def block=(_); end + + # Returns the value of attribute method_name + # + # @return [Object] the current value of method_name + def method_name; end + + # Sets the attribute method_name + # + # @param value [Object] the value to set the attribute method_name to. + # @return [Object] the newly set value + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:33 + def method_name=(_); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:34 + def playback_onto(group); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Shared example groups let you define common context and/or common +# examples that you wish to use in multiple example groups. +# +# When defined, the shared group block is stored for later evaluation. +# It can later be included in an example group either explicitly +# (using `include_examples`, `include_context` or `it_behaves_like`) +# or implicitly (via matching metadata). +# +# Named shared example groups are scoped based on where they are +# defined. Shared groups defined in an example group are available +# for inclusion in that example group or any child example groups, +# but not in any parent or sibling example groups. Shared example +# groups defined at the top level can be included from any example group. +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:57 +module RSpec::Core::SharedExampleGroup + # Stores the block for later use. The block will be evaluated + # in the context of an example group via `include_examples`, + # `include_context`, or `it_behaves_like`. + # + # @example + # shared_examples "auditable" do + # it "stores an audit record on save!" do + # expect { auditable.save! }.to change(Audit, :count).by(1) + # end + # end + # + # RSpec.describe Account do + # it_behaves_like "auditable" do + # let(:auditable) { Account.new } + # end + # end + # @overload shared_examples + # @overload shared_examples + # @see ExampleGroup.it_behaves_like + # @see ExampleGroup.include_examples + # @see ExampleGroup.include_context + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:90 + def shared_context(name, *args, &block); end + + # Stores the block for later use. The block will be evaluated + # in the context of an example group via `include_examples`, + # `include_context`, or `it_behaves_like`. + # + # @example + # shared_examples "auditable" do + # it "stores an audit record on save!" do + # expect { auditable.save! }.to change(Audit, :count).by(1) + # end + # end + # + # RSpec.describe Account do + # it_behaves_like "auditable" do + # let(:auditable) { Account.new } + # end + # end + # @overload shared_examples + # @overload shared_examples + # @see ExampleGroup.it_behaves_like + # @see ExampleGroup.include_examples + # @see ExampleGroup.include_context + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:90 + def shared_examples(name, *args, &block); end + + # Stores the block for later use. The block will be evaluated + # in the context of an example group via `include_examples`, + # `include_context`, or `it_behaves_like`. + # + # @example + # shared_examples "auditable" do + # it "stores an audit record on save!" do + # expect { auditable.save! }.to change(Audit, :count).by(1) + # end + # end + # + # RSpec.describe Account do + # it_behaves_like "auditable" do + # let(:auditable) { Account.new } + # end + # end + # @overload shared_examples + # @overload shared_examples + # @see ExampleGroup.it_behaves_like + # @see ExampleGroup.include_examples + # @see ExampleGroup.include_context + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:90 + def shared_examples_for(name, *args, &block); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:149 +class RSpec::Core::SharedExampleGroup::Registry + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:150 + def add(context, name, *metadata_args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:174 + def find(lookup_contexts, name); end + + private + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:257 + def ensure_block_has_source_location(_block); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:245 + def formatted_location(block); end + + # TODO: remove this in RSpec 4. This exists only to support + # `config.shared_context_metadata_behavior == :trigger_inclusion`, + # the legacy behavior of shared context metadata, which we do + # not want to support in RSpec 4. + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:189 + def legacy_add(context, name, *metadata_args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:204 + def shared_example_groups; end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:208 + def valid_name?(candidate); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:215 + def warn_if_key_taken(context, key, new_block); end +end + +# Shared examples top level DSL. +# +# @api private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:106 +module RSpec::Core::SharedExampleGroup::TopLevelDSL + class << self + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:108 + def definitions; end + + # Adds the top level DSL methods to Module and the top level binding. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:126 + def expose_globally!; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:119 + def exposed_globally?; end + + # Removes the top level DSL methods to Module and the top level binding. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:135 + def remove_globally!; end + end +end + +# Contains information about the inclusion site of a shared example group. +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:782 +class RSpec::Core::SharedExampleGroupInclusionStackFrame + # @private + # @return [SharedExampleGroupInclusionStackFrame] a new instance of SharedExampleGroupInclusionStackFrame + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:789 + def initialize(shared_group_name, inclusion_location); end + + # @return [String] Description of this stack frame, in the form used by + # RSpec's built-in formatters. + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:805 + def description; end + + # @return [String] The {#inclusion_location}, formatted for display by a formatter. + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:795 + def formatted_inclusion_location; end + + # @return [String] the location where the shared example was included + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:786 + def inclusion_location; end + + # @return [String] the name of the shared example group + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:784 + def shared_group_name; end + + class << self + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:811 + def current_backtrace; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:829 + def shared_example_group_inclusions; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:816 + def with_frame(name, location); end + end +end + +# Represents some functionality that is shared with multiple example groups. +# The functionality is defined by the provided block, which is lazily +# eval'd when the `SharedExampleGroupModule` instance is included in an example +# group. +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:10 +class RSpec::Core::SharedExampleGroupModule < ::Module + # @return [SharedExampleGroupModule] a new instance of SharedExampleGroupModule + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:13 + def initialize(description, definition, metadata); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:11 + def definition; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:34 + def include_in(klass, inclusion_line, args, customization_block); end + + # Ruby callback for when a module is included in another module is class. + # Our definition evaluates the shared group block in the context of the + # including example group. + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:28 + def included(klass); end + + # Provides a human-readable representation of this module. + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:20 + def inspect; end + + # Provides a human-readable representation of this module. + # + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:20 + def to_s; end +end + +# Deals with the fact that `shellwords` only works on POSIX systems. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:5 +module RSpec::Core::ShellEscape + private + + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:32 + def conditionally_quote(id); end + + # :nocov: + # + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:19 + def escape(shell_command); end + + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:8 + def quote(argument); end + + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:37 + def shell_allows_unquoted_ids?; end + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:32 + def conditionally_quote(id); end + + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:19 + def escape(shell_command); end + + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:8 + def quote(argument); end + + # @return [Boolean] + # + # source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:37 + def shell_allows_unquoted_ids?; end + end +end + +# Known shells that require quoting: zsh, csh, tcsh. +# +# Feel free to add other shells to this list that are known to +# allow `rspec ./some_spec.rb[1:1]` syntax without quoting the id. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shell_escape.rb:30 +RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array) + +# Provides an execution context for before/after :suite hooks. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example.rb:651 +class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example + # @return [SuiteHookContext] a new instance of SuiteHookContext + # + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:652 + def initialize(hook_description, reporter); end + + # source://rspec-core-3.11.0/lib/rspec/core/example.rb:659 + def set_exception(exception); end +end + +# This avoids issues with reporting time caused by examples that +# change the value/meaning of Time.now without properly restoring +# it. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core.rb:174 +class RSpec::Core::Time + class << self + def now(*_arg0); end + end +end + +# Version information for RSpec Core. +# +# source://rspec-core-3.11.0/lib/rspec/core/version.rb:4 +module RSpec::Core::Version; end + +# Current version of RSpec Core, in semantic versioning format. +# +# source://rspec-core-3.11.0/lib/rspec/core/version.rb:6 +RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/warnings.rb:6 +module RSpec::Core::Warnings + # Used internally to print deprecation warnings. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/warnings.rb:10 + def deprecate(deprecated, data = T.unsafe(nil)); end + + # Used internally to print deprecation warnings. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/warnings.rb:22 + def warn_deprecation(message, opts = T.unsafe(nil)); end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/warnings.rb:27 + def warn_with(message, options = T.unsafe(nil)); end +end + +# Internal container for global non-configuration data. +# +# @api private +# +# source://rspec-core-3.11.0/lib/rspec/core/world.rb:6 +class RSpec::Core::World + # @api private + # @return [World] a new instance of World + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:26 + def initialize(configuration = T.unsafe(nil)); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:115 + def all_example_groups; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:120 + def all_examples; end + + # Add exclusion filters to announcement message. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:226 + def announce_exclusion_filter(announcements); end + + # Notify reporter of filters. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:171 + def announce_filters; end + + # Add inclusion filters to announcement message. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:217 + def announce_inclusion_filter(announcements); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:210 + def everything_filtered_message; end + + # Get count of examples to be run. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:109 + def example_count(groups = T.unsafe(nil)); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:8 + def example_group_counts_by_spec_file; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:8 + def example_groups; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:102 + def exclusion_filter; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:69 + def filter_manager; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:8 + def filtered_examples; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:97 + def inclusion_filter; end + + # Used internally to signal that a failure outside of an example + # has occurred, and that therefore the exit status should indicate + # the run failed. + # + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:24 + def non_example_failure; end + + # Used internally to signal that a failure outside of an example + # has occurred, and that therefore the exit status should indicate + # the run failed. + # + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:24 + def non_example_failure=(_arg0); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:87 + def num_example_groups_defined_in(file); end + + # Apply ordering strategy from configuration to example groups. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:52 + def ordered_example_groups; end + + # Find line number of previous declaration. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:140 + def preceding_declaration_line(absolute_file_name, filter_line); end + + # Prepares filters so that they apply to example groups when they run. + # + # This is a separate method so that filters can be modified/replaced and + # examples refiltered during a process's lifetime, which can be useful for + # a custom runner. + # + # @api public + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:43 + def prepare_example_filtering; end + + # Records an example group. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:81 + def record(example_group); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:74 + def registered_example_group_files; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:205 + def report_filter_message(message); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:149 + def reporter; end + + # Reset world to 'scratch' before running suite. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:60 + def reset; end + + # Used internally to signify that a SystemExit occurred in + # `Configuration#load_file_handling_errors`, and thus examples cannot + # be counted accurately. Specifically, we cannot accurately report + # "No examples found". + # + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:18 + def rspec_is_quitting; end + + # Used internally to signify that a SystemExit occurred in + # `Configuration#load_file_handling_errors`, and thus examples cannot + # be counted accurately. Specifically, we cannot accurately report + # "No examples found". + # + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:18 + def rspec_is_quitting=(_arg0); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:92 + def shared_example_group_registry; end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:154 + def source_from_file(path); end + + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:164 + def syntax_highlighter; end + + # Traverses the tree of each top level group. + # For each it yields the group, then the children, recursively. + # Halts the traversal of a branch of the tree as soon as the passed block returns true. + # Note that siblings groups and their sub-trees will continue to be explored. + # This is intended to make it easy to find the top-most group that satisfies some + # condition. + # + # @api private + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:131 + def traverse_example_group_trees_until(&block); end + + # Used internally to determine what to do when a SIGINT is received. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:11 + def wants_to_quit; end + + # Used internally to determine what to do when a SIGINT is received. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:11 + def wants_to_quit=(_arg0); end + + private + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:234 + def descending_declaration_line_numbers_by_file; end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:252 + def fail_if_config_and_cli_options_invalid; end +end + +# Provides a null implementation for initial use by configuration. +# +# @api private +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/world.rb:264 +module RSpec::Core::World::Null + class << self + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:280 + def all_example_groups; end + + # :nocov: + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:276 + def example_groups; end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:265 + def non_example_failure; end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:266 + def non_example_failure=(_); end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:268 + def registered_example_group_files; end + + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core/world.rb:272 + def traverse_example_group_trees_until; end + end +end + +# Namespace for the example group subclasses generated by top-level +# `describe`. +# +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:839 +module RSpec::ExampleGroups + extend ::RSpec::Support::RecursiveConstMethods + + class << self + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:842 + def assign_const(group); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:862 + def base_name_for(group); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:850 + def constant_scope_for(group); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:895 + def disambiguate(name, const_scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/example_group.rb:856 + def remove_all_constants; end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core.rb:187 +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:54 +RSpec::SharedContext = RSpec::Core::SharedContext diff --git a/sorbet/rbi/gems/rspec-expectations.rbi b/sorbet/rbi/gems/rspec-expectations.rbi deleted file mode 100644 index e8d42804..00000000 --- a/sorbet/rbi/gems/rspec-expectations.rbi +++ /dev/null @@ -1,1173 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi -# -# rspec-expectations-3.11.0 - -module RSpec -end -module RSpec::Matchers - def a_block_changing(*args, &block); end - def a_block_outputting(*args, &block); end - def a_block_raising(*args, &block); end - def a_block_throwing(*args, &block); end - def a_block_yielding_control(*args, &block); end - def a_block_yielding_successive_args(*args, &block); end - def a_block_yielding_with_args(*args, &block); end - def a_block_yielding_with_no_args(*args, &block); end - def a_collection_containing_exactly(*args, &block); end - def a_collection_ending_with(*args, &block); end - def a_collection_including(*args, &block); end - def a_collection_starting_with(*args, &block); end - def a_falsey_value(*args, &block); end - def a_falsy_value(*args, &block); end - def a_hash_including(*args, &block); end - def a_kind_of(*args, &block); end - def a_nil_value(*args, &block); end - def a_range_covering(*args, &block); end - def a_string_ending_with(*args, &block); end - def a_string_including(*args, &block); end - def a_string_matching(*args, &block); end - def a_string_starting_with(*args, &block); end - def a_truthy_value(*args, &block); end - def a_value(*args, &block); end - def a_value_between(*args, &block); end - def a_value_within(*args, &block); end - def aggregate_failures(label = nil, metadata = nil, &block); end - def all(expected); end - def an_instance_of(*args, &block); end - def an_object_eq_to(*args, &block); end - def an_object_eql_to(*args, &block); end - def an_object_equal_to(*args, &block); end - def an_object_existing(*args, &block); end - def an_object_having_attributes(*args, &block); end - def an_object_matching(*args, &block); end - def an_object_responding_to(*args, &block); end - def an_object_satisfying(*args, &block); end - def be(*args); end - def be_a(klass); end - def be_a_kind_of(expected); end - def be_an(klass); end - def be_an_instance_of(expected); end - def be_between(min, max); end - def be_falsey; end - def be_falsy(*args, &block); end - def be_instance_of(expected); end - def be_kind_of(expected); end - def be_nil; end - def be_truthy; end - def be_within(delta); end - def change(receiver = nil, message = nil, &block); end - def changing(*args, &block); end - def contain_exactly(*items); end - def containing_exactly(*args, &block); end - def cover(*values); end - def covering(*args, &block); end - def end_with(*expected); end - def ending_with(*args, &block); end - def eq(expected); end - def eq_to(*args, &block); end - def eql(expected); end - def eql_to(*args, &block); end - def equal(expected); end - def equal_to(*args, &block); end - def exist(*args); end - def existing(*args, &block); end - def expect(value = nil, &block); end - def have_attributes(expected); end - def having_attributes(*args, &block); end - def include(*expected); end - def including(*args, &block); end - def match(expected); end - def match_array(items); end - def match_regex(*args, &block); end - def matching(*args, &block); end - def method_missing(method, *args, &block); end - def output(expected = nil); end - def raise_error(error = nil, message = nil, &block); end - def raise_exception(error = nil, message = nil, &block); end - def raising(*args, &block); end - def respond_to(*names); end - def respond_to_missing?(method, *arg1); end - def responding_to(*args, &block); end - def satisfy(description = nil, &block); end - def satisfying(*args, &block); end - def self.alias_matcher(*args, &block); end - def self.clear_generated_description; end - def self.configuration; end - def self.generated_description; end - def self.is_a_describable_matcher?(obj); end - def self.is_a_matcher?(obj); end - def self.last_description; end - def self.last_expectation_handler; end - def self.last_expectation_handler=(arg0); end - def self.last_matcher; end - def self.last_matcher=(arg0); end - def start_with(*expected); end - def starting_with(*args, &block); end - def throw_symbol(expected_symbol = nil, expected_arg = nil); end - def throwing(*args, &block); end - def within(*args, &block); end - def yield_control; end - def yield_successive_args(*args); end - def yield_with_args(*args); end - def yield_with_no_args; end - def yielding_control(*args, &block); end - def yielding_successive_args(*args, &block); end - def yielding_with_args(*args, &block); end - def yielding_with_no_args(*args, &block); end - extend RSpec::Matchers::DSL -end -module RSpec::Matchers::EnglishPhrasing - def self.list(obj); end - def self.split_words(sym); end -end -module RSpec::Matchers::Composable - def &(matcher); end - def ===(value); end - def and(matcher); end - def description_of(object); end - def or(matcher); end - def self.should_enumerate?(item); end - def self.surface_descriptions_in(item); end - def self.unreadable_io?(object); end - def should_enumerate?(item); end - def surface_descriptions_in(item); end - def unreadable_io?(object); end - def values_match?(expected, actual); end - def with_matchers_cloned(object); end - def |(matcher); end -end -class RSpec::Matchers::Composable::DescribableItem < Struct - def inspect; end - def item; end - def item=(_); end - def pretty_print(pp); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -module RSpec::Matchers::BuiltIn -end -class RSpec::Matchers::BuiltIn::BaseMatcher - def actual; end - def actual_formatted; end - def assert_ivars(*expected_ivars); end - def description; end - def diffable?; end - def expected; end - def expected_formatted; end - def expects_call_stack_jump?; end - def initialize(expected = nil); end - def match_unless_raises(*exceptions); end - def matcher_name; end - def matcher_name=(arg0); end - def matches?(actual); end - def present_ivars; end - def rescued_exception; end - def self.matcher_name; end - def self.underscore(camel_cased_word); end - def supports_block_expectations?; end - def supports_value_expectations?; end - include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - include RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting - include RSpec::Matchers::Composable -end -module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting - def improve_hash_formatting(inspect_string); end - def self.improve_hash_formatting(inspect_string); end -end -module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - def failure_message; end - def failure_message_when_negated; end - def self.has_default_failure_messages?(matcher); end -end -module RSpec::Matchers::DSL - def alias_matcher(new_name, old_name, options = nil, &description_override); end - def define(name, &declarations); end - def define_negated_matcher(negated_name, base_name, &description_override); end - def matcher(name, &declarations); end - def warn_about_block_args(name, declarations); end -end -module RSpec::Matchers::DSL::Macros - def assign_attributes(attr_names); end - def chain(method_name, *attr_names, &definition); end - def define_user_override(method_name, user_def, &our_def); end - def description(&definition); end - def diffable; end - def failure_message(&definition); end - def failure_message_when_negated(&definition); end - def match(options = nil, &match_block); end - def match_unless_raises(expected_exception = nil, &match_block); end - def match_when_negated(options = nil, &match_block); end - def supports_block_expectations; end -end -module RSpec::Matchers::DSL::Macros::Deprecated - def failure_message_for_should(&definition); end - def failure_message_for_should_not(&definition); end - def match_for_should(&definition); end - def match_for_should_not(&definition); end -end -module RSpec::Matchers::DSL::DefaultImplementations - def chained_method_clause_sentences; end - def description; end - def diffable?; end - def expects_call_stack_jump?; end - def supports_block_expectations?; end - def supports_value_expectations?; end - include RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages -end -class RSpec::Matchers::DSL::Matcher - def actual; end - def actual_arg_for(block); end - def block_arg; end - def expected; end - def expected_as_array; end - def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end - def inspect; end - def method_missing(method, *args, &block); end - def name; end - def rescued_exception; end - def respond_to_missing?(method, include_private = nil); end - extend RSpec::Matchers::DSL::Macros - extend RSpec::Matchers::DSL::Macros::Deprecated - include RSpec::Matchers - include RSpec::Matchers::Composable - include RSpec::Matchers::DSL::DefaultImplementations -end -class RSpec::Matchers::MatcherDelegator - def base_matcher; end - def initialize(base_matcher); end - def initialize_copy(other); end - def method_missing(*args, &block); end - def respond_to_missing?(name, include_all = nil); end - include RSpec::Matchers::Composable -end -class RSpec::Matchers::AliasedMatcher < RSpec::Matchers::MatcherDelegator - def description; end - def failure_message; end - def failure_message_when_negated; end - def initialize(base_matcher, description_block); end - def method_missing(*arg0); end -end -class RSpec::Matchers::AliasedMatcherWithOperatorSupport < RSpec::Matchers::AliasedMatcher -end -class RSpec::Matchers::AliasedNegatedMatcher < RSpec::Matchers::AliasedMatcher - def does_not_match?(*args, &block); end - def failure_message; end - def failure_message_when_negated; end - def matches?(*args, &block); end - def optimal_failure_message(same, inverted); end -end -class RSpec::Matchers::ExpectedsForMultipleDiffs - def diffs(differ, actual); end - def initialize(expected_list); end - def message_with_diff(message, differ, actual); end - def self.diff_label_for(matcher); end - def self.for_many_matchers(matchers); end - def self.from(expected); end - def self.truncated(description); end -end -module RSpec::Support - def self.require_rspec_expectations(f); end - def self.require_rspec_matchers(f); end -end -module RSpec::Expectations - def self.configuration; end - def self.differ; end - def self.fail_with(message, expected = nil, actual = nil); end -end -class RSpec::Expectations::ExpectationTarget - def initialize(value); end - def self.for(value, block); end - def target; end - include RSpec::Expectations::ExpectationTarget::InstanceMethods -end -module RSpec::Expectations::ExpectationTarget::UndefinedValue -end -module RSpec::Expectations::ExpectationTarget::InstanceMethods - def not_to(matcher = nil, message = nil, &block); end - def prevent_operator_matchers(verb); end - def to(matcher = nil, message = nil, &block); end - def to_not(matcher = nil, message = nil, &block); end -end -class RSpec::Expectations::ValueExpectationTarget < RSpec::Expectations::ExpectationTarget - def enforce_value_expectation(matcher); end - def not_to(matcher = nil, message = nil, &block); end - def supports_value_expectations?(matcher); end - def to(matcher = nil, message = nil, &block); end -end -class RSpec::Expectations::BlockExpectationTarget < RSpec::Expectations::ExpectationTarget - def enforce_block_expectation(matcher); end - def not_to(matcher, message = nil, &block); end - def supports_block_expectations?(matcher); end - def to(matcher, message = nil, &block); end - def to_not(matcher, message = nil, &block); end -end -module RSpec::Expectations::Syntax - def default_should_host; end - def disable_expect(syntax_host = nil); end - def disable_should(syntax_host = nil); end - def enable_expect(syntax_host = nil); end - def enable_should(syntax_host = nil); end - def expect_enabled?(syntax_host = nil); end - def self.default_should_host; end - def self.disable_expect(syntax_host = nil); end - def self.disable_should(syntax_host = nil); end - def self.enable_expect(syntax_host = nil); end - def self.enable_should(syntax_host = nil); end - def self.expect_enabled?(syntax_host = nil); end - def self.should_enabled?(syntax_host = nil); end - def self.warn_about_should!; end - def self.warn_about_should_unless_configured(method_name); end - def should_enabled?(syntax_host = nil); end - def warn_about_should!; end - def warn_about_should_unless_configured(method_name); end -end -class BasicObject - def should(matcher = nil, message = nil, &block); end - def should_not(matcher = nil, message = nil, &block); end -end -class RSpec::Expectations::Configuration - def add_should_and_should_not_to(*modules); end - def backtrace_formatter; end - def backtrace_formatter=(arg0); end - def color?; end - def false_positives_handler; end - def include_chain_clauses_in_custom_matcher_descriptions=(arg0); end - def include_chain_clauses_in_custom_matcher_descriptions?; end - def initialize; end - def max_formatted_output_length=(length); end - def on_potential_false_positives; end - def on_potential_false_positives=(behavior); end - def reset_syntaxes_to_default; end - def strict_predicate_matchers; end - def strict_predicate_matchers=(flag); end - def strict_predicate_matchers?; end - def syntax; end - def syntax=(values); end - def warn_about_potential_false_positives=(boolean); end - def warn_about_potential_false_positives?; end -end -module RSpec::Expectations::Configuration::NullBacktraceFormatter - def self.format_backtrace(backtrace); end -end -class InvalidName___Class_0x00___Differ_2 -end -module RSpec::Expectations::ExpectationHelper - def self.check_message(msg); end - def self.handle_failure(matcher, message, failure_message_method); end - def self.modern_matcher_from(matcher); end - def self.with_matcher(handler, matcher, message); end -end -class RSpec::Expectations::PositiveExpectationHandler - def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end - def self.opposite_should_method; end - def self.should_method; end - def self.verb; end -end -class RSpec::Expectations::NegativeExpectationHandler - def self.does_not_match?(matcher, actual, &block); end - def self.handle_matcher(actual, initial_matcher, custom_message = nil, &block); end - def self.opposite_should_method; end - def self.should_method; end - def self.verb; end -end -class RSpec::Expectations::LegacyMatcherAdapter < RSpec::Matchers::MatcherDelegator - def initialize(matcher); end - def self.wrap(matcher); end -end -class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < RSpec::Expectations::LegacyMatcherAdapter - def failure_message; end - def failure_message_when_negated; end - def self.interface_matches?(matcher); end -end -class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < RSpec::Expectations::LegacyMatcherAdapter - def failure_message; end - def failure_message_when_negated; end - def self.interface_matches?(matcher); end -end -module RSpec::Expectations::Version -end -class RSpec::Expectations::ExpectationNotMetError < Exception -end -class RSpec::Expectations::MultipleExpectationsNotMetError < RSpec::Expectations::ExpectationNotMetError - def aggregation_block_label; end - def aggregation_metadata; end - def all_exceptions; end - def backtrace_line(line); end - def block_description; end - def enumerated(exceptions, index_offset); end - def enumerated_errors; end - def enumerated_failures; end - def exception_count_description; end - def exclusion_patterns; end - def failures; end - def format_backtrace(backtrace); end - def indentation; end - def indented(failure_message, index); end - def index_label(index); end - def initialize(failure_aggregator); end - def longest_index_label_width; end - def message; end - def other_errors; end - def pluralize(noun, count); end - def summary; end - def width_of_label(index); end -end -class RSpec::Expectations::BlockSnippetExtractor - def beginning_line_number; end - def block_token_extractor; end - def body_content_lines; end - def file_path; end - def initialize(proc, method_name); end - def method_name; end - def proc; end - def raw_body_lines; end - def raw_body_snippet; end - def self.try_extracting_single_line_body_of(proc, method_name); end - def source; end - def source_location; end -end -class RSpec::Expectations::BlockSnippetExtractor::Error < StandardError -end -class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < RSpec::Expectations::BlockSnippetExtractor::Error -end -class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < RSpec::Expectations::BlockSnippetExtractor::Error -end -class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < Struct - def after_beginning_of_args_state(token); end - def after_beginning_of_body_state(token); end - def after_method_call_state(token); end - def after_opener_state(token); end - def beginning_line_number; end - def beginning_line_number=(_); end - def block_locator; end - def body_tokens; end - def correct_block?(body_tokens); end - def finalize_pending_tokens!; end - def finish!; end - def finish_or_find_next_block_if_incorrect!; end - def handle_closer_token(token); end - def handle_opener_token(token); end - def initial_state(token); end - def initialize(*arg0); end - def invoke_state_handler(token); end - def method_name; end - def method_name=(_); end - def opener_token?(token); end - def opener_token_stack; end - def parse!; end - def pending_tokens; end - def pipe_token?(token); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def source; end - def source=(_); end - def state; end -end -class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < Struct - def beginning_line_number; end - def beginning_line_number=(_); end - def block_body_node; end - def block_wrapper_node; end - def body_content_locations; end - def candidate_block_wrapper_nodes; end - def candidate_method_ident_nodes; end - def method_call_location; end - def method_ident_node; end - def method_ident_node?(node); end - def method_name; end - def method_name=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def source; end - def source=(_); end -end -class RSpec::Expectations::FailureAggregator - def aggregate; end - def assign_backtrace(failure); end - def block_label; end - def call(failure, options); end - def failures; end - def initialize(block_label, metadata); end - def metadata; end - def notify_aggregated_failures; end - def other_errors; end -end -class RSpec::Matchers::BuiltIn::BeAKindOf < RSpec::Matchers::BuiltIn::BaseMatcher - def match(expected, actual); end -end -class RSpec::Matchers::BuiltIn::BeAnInstanceOf < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def match(expected, actual); end -end -class RSpec::Matchers::BuiltIn::BeBetween < RSpec::Matchers::BuiltIn::BaseMatcher - def comparable?; end - def compare; end - def description; end - def exclusive; end - def failure_message; end - def inclusive; end - def initialize(min, max); end - def matches?(actual); end - def not_comparable_clause; end -end -class RSpec::Matchers::BuiltIn::BeTruthy < RSpec::Matchers::BuiltIn::BaseMatcher - def failure_message; end - def failure_message_when_negated; end - def match(_, actual); end -end -class RSpec::Matchers::BuiltIn::BeFalsey < RSpec::Matchers::BuiltIn::BaseMatcher - def failure_message; end - def failure_message_when_negated; end - def match(_, actual); end -end -class RSpec::Matchers::BuiltIn::BeNil < RSpec::Matchers::BuiltIn::BaseMatcher - def failure_message; end - def failure_message_when_negated; end - def match(_, actual); end -end -module RSpec::Matchers::BuiltIn::BeHelpers - def args_to_s; end - def args_to_sentence; end - def expected_to_sentence; end - def inspected_args; end - def parenthesize(string); end -end -class RSpec::Matchers::BuiltIn::Be < RSpec::Matchers::BuiltIn::BaseMatcher - def <(operand); end - def <=(operand); end - def ==(operand); end - def ===(operand); end - def =~(operand); end - def >(operand); end - def >=(operand); end - def failure_message; end - def failure_message_when_negated; end - def initialize(*args); end - def match(_, actual); end - include RSpec::Matchers::BuiltIn::BeHelpers -end -class RSpec::Matchers::BuiltIn::BeComparedTo < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def does_not_match?(actual); end - def failure_message; end - def failure_message_when_negated; end - def initialize(operand, operator); end - def matches?(actual); end - def perform_match(actual); end - include RSpec::Matchers::BuiltIn::BeHelpers -end -class RSpec::Matchers::BuiltIn::DynamicPredicate < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def does_not_match?(actual, &block); end - def expectation_of(value); end - def failure_message; end - def failure_message_expecting(value); end - def failure_message_when_negated; end - def failure_to_respond_explanation; end - def initialize(method_name, *args, &block); end - def matches?(actual, &block); end - def method_description; end - def predicate_accessible?; end - def predicate_matches?(value = nil); end - def predicate_method_name; end - def predicate_result; end - def private_predicate?; end - def root; end - def validity_message; end - include RSpec::Matchers::BuiltIn::BeHelpers -end -class RSpec::Matchers::BuiltIn::Has < RSpec::Matchers::BuiltIn::DynamicPredicate - def predicate; end -end -class RSpec::Matchers::BuiltIn::BePredicate < RSpec::Matchers::BuiltIn::DynamicPredicate - def failure_to_respond_explanation; end - def predicate; end - def predicate_accessible?; end - def predicate_method_name; end - def present_tense_predicate; end -end -class RSpec::Matchers::BuiltIn::BeWithin < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def failure_message; end - def failure_message_when_negated; end - def initialize(delta); end - def matches?(actual); end - def needs_expected; end - def not_numeric_clause; end - def numeric?; end - def of(expected); end - def percent_of(expected); end -end -class RSpec::Matchers::BuiltIn::Change < RSpec::Matchers::BuiltIn::BaseMatcher - def by(expected_delta); end - def by_at_least(minimum); end - def by_at_most(maximum); end - def change_details; end - def description; end - def does_not_match?(event_proc); end - def failure_message; end - def failure_message_when_negated; end - def from(value); end - def initialize(receiver = nil, message = nil, &block); end - def matches?(event_proc); end - def negative_failure_reason; end - def perform_change(event_proc); end - def positive_failure_reason; end - def raise_block_syntax_error; end - def supports_block_expectations?; end - def supports_value_expectations?; end - def to(value); end -end -class RSpec::Matchers::BuiltIn::ChangeRelatively < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def does_not_match?(_event_proc); end - def failure_message; end - def failure_reason; end - def initialize(change_details, expected_delta, relativity, &comparer); end - def matches?(event_proc); end - def supports_block_expectations?; end - def supports_value_expectations?; end -end -class RSpec::Matchers::BuiltIn::SpecificValuesChange < RSpec::Matchers::BuiltIn::BaseMatcher - def after_value_failure; end - def before_value_failure; end - def description; end - def did_change_failure; end - def did_not_change_failure; end - def failure_message; end - def initialize(change_details, from, to); end - def matches?(event_proc); end - def matches_after?; end - def not_given_a_block_failure; end - def perform_change(event_proc); end - def supports_block_expectations?; end - def supports_value_expectations?; end -end -class RSpec::Matchers::BuiltIn::ChangeFromValue < RSpec::Matchers::BuiltIn::SpecificValuesChange - def change_description; end - def does_not_match?(event_proc); end - def failure_message_when_negated; end - def initialize(change_details, expected_before); end - def to(value); end -end -class RSpec::Matchers::BuiltIn::ChangeToValue < RSpec::Matchers::BuiltIn::SpecificValuesChange - def change_description; end - def does_not_match?(_event_proc); end - def from(value); end - def initialize(change_details, expected_after); end -end -class RSpec::Matchers::BuiltIn::ChangeDetails - def actual_after; end - def actual_delta; end - def changed?; end - def evaluate_value_proc; end - def extract_value_block_snippet; end - def initialize(matcher_name, receiver = nil, message = nil, &block); end - def message_notation(receiver, message); end - def perform_change(event_proc); end - def value_representation; end -end -module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED -end -class RSpec::Matchers::BuiltIn::Compound < RSpec::Matchers::BuiltIn::BaseMatcher - def compound_failure_message; end - def description; end - def diffable?; end - def diffable_matcher_list; end - def diffable_matcher_list_for(matcher); end - def does_not_match?(_actual); end - def evaluator; end - def expected; end - def expects_call_stack_jump?; end - def indent_multiline_message(message); end - def initialize(matcher_1, matcher_2); end - def initialize_copy(other); end - def match(_expected, actual); end - def matcher_1; end - def matcher_1_matches?; end - def matcher_2; end - def matcher_2_matches?; end - def matcher_is_diffable?(matcher); end - def matcher_supports_block_expectations?(matcher); end - def matcher_supports_value_expectations?(matcher); end - def supports_block_expectations?; end - def supports_value_expectations?; end -end -class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator - def initialize(actual, *arg1); end - def matcher_matches?(matcher); end -end -class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator - def initialize(actual, matcher_1, matcher_2); end - def inner_matcher_block(outer_args); end - def matcher_matches?(matcher); end - def order_block_matchers; end - def self.matcher_expects_call_stack_jump?(matcher); end -end -class RSpec::Matchers::BuiltIn::Compound::And < RSpec::Matchers::BuiltIn::Compound - def conjunction; end - def failure_message; end - def match(*arg0); end -end -class RSpec::Matchers::BuiltIn::Compound::Or < RSpec::Matchers::BuiltIn::Compound - def conjunction; end - def failure_message; end - def match(*arg0); end -end -class RSpec::Matchers::BuiltIn::ContainExactly < RSpec::Matchers::BuiltIn::BaseMatcher - def actual_collection_line; end - def best_solution; end - def convert_actual_to_an_array; end - def describe_collection(collection, surface_descriptions = nil); end - def description; end - def expected_collection_line; end - def extra_elements_line; end - def extra_items; end - def failure_message; end - def failure_message_when_negated; end - def generate_failure_message; end - def match(_expected, _actual); end - def match_when_sorted?; end - def message_line(prefix, collection, surface_descriptions = nil); end - def missing_elements_line; end - def missing_items; end - def pairings_maximizer; end - def safe_sort(array); end - def to_a_disallowed?(object); end -end -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer - def actual_to_expected_matched_indexes; end - def apply_pairing_to(indeterminates, original_matches, other_list_index); end - def best_solution_for_pairing(expected_index, actual_index); end - def categorize_indexes(indexes_to_categorize, other_indexes); end - def expected_to_actual_matched_indexes; end - def find_best_solution; end - def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end - def reciprocal_single_match?(matches, index, other_list); end - def solution; end -end -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < Struct - def +(derived_candidate_solution); end - def candidate?; end - def ideal?; end - def indeterminate_actual_indexes; end - def indeterminate_actual_indexes=(_); end - def indeterminate_expected_indexes; end - def indeterminate_expected_indexes=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def unmatched_actual_indexes; end - def unmatched_actual_indexes=(_); end - def unmatched_expected_indexes; end - def unmatched_expected_indexes=(_); end - def unmatched_item_count; end - def worse_than?(other); end -end -class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution - def self.worse_than?(_other); end -end -class RSpec::Matchers::BuiltIn::Cover < RSpec::Matchers::BuiltIn::BaseMatcher - def does_not_match?(range); end - def initialize(*expected); end - def matches?(range); end -end -class RSpec::Matchers::BuiltIn::StartOrEndWith < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def failure_message; end - def initialize(*expected); end - def match(_expected, actual); end - def subsets_comparable?; end -end -class RSpec::Matchers::BuiltIn::StartWith < RSpec::Matchers::BuiltIn::StartOrEndWith - def element_matches?; end - def subset_matches?; end -end -class RSpec::Matchers::BuiltIn::EndWith < RSpec::Matchers::BuiltIn::StartOrEndWith - def element_matches?; end - def subset_matches?; end -end -class RSpec::Matchers::BuiltIn::Eq < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def diffable?; end - def failure_message; end - def failure_message_when_negated; end - def match(expected, actual); end -end -class RSpec::Matchers::BuiltIn::Eql < RSpec::Matchers::BuiltIn::BaseMatcher - def diffable?; end - def failure_message; end - def failure_message_when_negated; end - def match(expected, actual); end -end -class RSpec::Matchers::BuiltIn::Equal < RSpec::Matchers::BuiltIn::BaseMatcher - def actual_inspected; end - def detailed_failure_message; end - def diffable?; end - def expected_is_a_literal_singleton?; end - def failure_message; end - def failure_message_when_negated; end - def inspect_object(o); end - def match(expected, actual); end - def simple_failure_message; end -end -class RSpec::Matchers::BuiltIn::Exist < RSpec::Matchers::BuiltIn::BaseMatcher - def does_not_match?(actual); end - def failure_message; end - def failure_message_when_negated; end - def initialize(*expected); end - def matches?(actual); end -end -class Anonymous_Struct_3 < Struct - def actual; end - def actual=(_); end - def expected; end - def expected=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < Anonymous_Struct_3 - def actual_exists?; end - def deprecated(predicate, actual); end - def existence_values; end - def predicates; end - def uniq_truthy_values; end - def valid_test?; end - def validity_message; end -end -class RSpec::Matchers::BuiltIn::HaveAttributes < RSpec::Matchers::BuiltIn::BaseMatcher - def actual; end - def actual_has_attribute?(attribute_key, attribute_value); end - def cache_all_values; end - def description; end - def diffable?; end - def does_not_match?(actual); end - def failure_message; end - def failure_message_when_negated; end - def formatted_values; end - def initialize(expected); end - def matches?(actual); end - def perform_match(predicate); end - def respond_to_attributes?; end - def respond_to_failed; end - def respond_to_failure_message_or; end - def respond_to_matcher; end -end -module RSpec::Matchers::BuiltIn::CountExpectation - def at_least(number); end - def at_most(number); end - def count_constraint_to_number(n); end - def count_expectation_description; end - def count_expectation_type; end - def count_failure_reason(action); end - def cover?(count, number); end - def exactly(number); end - def expected_count; end - def expected_count_matches?(actual_count); end - def has_expected_count?; end - def human_readable_count(count); end - def human_readable_expectation_type; end - def once; end - def raise_impossible_count_expectation(count); end - def raise_unsupported_count_expectation; end - def set_expected_count(relativity, n); end - def thrice; end - def times; end - def twice; end - def unsupported_count_expectation?(relativity); end -end -class RSpec::Matchers::BuiltIn::Include < RSpec::Matchers::BuiltIn::BaseMatcher - def actual_collection_includes?(expected_item); end - def actual_hash_has_key?(expected_key); end - def actual_hash_includes?(expected_key, expected_value); end - def check_actual?(actual); end - def check_expected_count?; end - def comparing_hash_keys?(expected_item); end - def comparing_hash_to_a_subset?(expected_item); end - def convert_to_hash?(obj); end - def count_enumerable(expected_item); end - def count_inclusions; end - def description; end - def diff_would_wrongly_highlight_matched_item?; end - def diffable?; end - def does_not_match?(actual); end - def excluded_from_actual; end - def expected; end - def expecteds; end - def failure_message; end - def failure_message_when_negated; end - def format_failure_message(preposition); end - def initialize(*expecteds); end - def matches?(actual); end - def perform_match(&block); end - def readable_list_of(items); end - include RSpec::Matchers::BuiltIn::CountExpectation -end -class RSpec::Matchers::BuiltIn::All < RSpec::Matchers::BuiltIn::BaseMatcher - def add_new_line_if_needed(message); end - def description; end - def does_not_match?(_actual); end - def failed_objects; end - def failure_message; end - def failure_message_for_item(index, failure_message); end - def indent_multiline_message(message); end - def index_failed_objects; end - def initialize(matcher); end - def initialize_copy(other); end - def iterable?; end - def match(_expected, _actual); end - def matcher; end -end -class RSpec::Matchers::BuiltIn::Match < RSpec::Matchers::BuiltIn::BaseMatcher - def can_safely_call_match?(expected, actual); end - def description; end - def diffable?; end - def initialize(expected); end - def match(expected, actual); end - def match_captures(expected, actual); end - def with_captures(*captures); end -end -class RSpec::Matchers::BuiltIn::ReliableMatchData - def captures; end - def initialize(match_data); end - def match_data; end - def names; end -end -class RSpec::Matchers::BuiltIn::OperatorMatcher - def !=(_expected); end - def !~(_expected); end - def <(expected); end - def <=(expected); end - def ==(expected); end - def ===(expected); end - def =~(expected); end - def >(expected); end - def >=(expected); end - def description; end - def eval_match(actual, operator, expected); end - def fail_with_message(message); end - def has_non_generic_implementation_of?(op); end - def initialize(actual); end - def self.get(klass, operator); end - def self.register(klass, operator, matcher); end - def self.registry; end - def self.unregister(klass, operator); end - def self.use_custom_matcher_or_delegate(operator); end -end -class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher - def __delegate_operator(actual, operator, expected); end -end -class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < RSpec::Matchers::BuiltIn::OperatorMatcher - def __delegate_operator(actual, operator, expected); end -end -class RSpec::Matchers::BuiltIn::Output < RSpec::Matchers::BuiltIn::BaseMatcher - def actual_output_description; end - def captured?; end - def description; end - def diffable?; end - def does_not_match?(block); end - def failure_message; end - def failure_message_when_negated; end - def initialize(expected); end - def matches?(block); end - def negative_failure_reason; end - def positive_failure_reason; end - def supports_block_expectations?; end - def supports_value_expectations?; end - def to_stderr; end - def to_stderr_from_any_process; end - def to_stdout; end - def to_stdout_from_any_process; end -end -module RSpec::Matchers::BuiltIn::NullCapture - def self.capture(_block); end - def self.name; end -end -module RSpec::Matchers::BuiltIn::CaptureStdout - def self.capture(block); end - def self.name; end -end -module RSpec::Matchers::BuiltIn::CaptureStderr - def self.capture(block); end - def self.name; end -end -class Anonymous_Struct_4 < Struct - def name; end - def name=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def stream; end - def stream=(_); end -end -class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < Anonymous_Struct_4 - def capture(block); end -end -class RSpec::Matchers::BuiltIn::RaiseError - def actual_error_message; end - def block_matches?; end - def description; end - def does_not_match?(given_proc); end - def error_and_message_match?; end - def eval_block; end - def expectation_matched?; end - def expected_error; end - def expecting_specific_exception?; end - def expects_call_stack_jump?; end - def failure_message; end - def failure_message_when_negated; end - def format_backtrace(backtrace); end - def given_error; end - def handle_warning(message); end - def initialize(expected_error_or_message, expected_message, &block); end - def matches?(given_proc, negative_expectation = nil, &block); end - def raise_message_already_set; end - def ready_to_eval_block?; end - def supports_block_expectations?; end - def supports_value_expectations?; end - def verify_message; end - def warn_about_bare_error!; end - def warn_about_bare_error?; end - def warn_about_negative_false_positive!(expression); end - def warn_about_nil_error!; end - def warn_about_nil_error?; end - def warn_for_negative_false_positives!; end - def warning; end - def with_message(expected_message); end - include RSpec::Matchers::Composable -end -class RSpec::Matchers::BuiltIn::RespondTo < RSpec::Matchers::BuiltIn::BaseMatcher - def and_any_keywords; end - def and_keywords(*keywords); end - def and_unlimited_arguments; end - def argument; end - def arguments; end - def description; end - def does_not_match?(actual); end - def failure_message; end - def failure_message_when_negated; end - def find_failing_method_names(actual, filter_method); end - def ignoring_method_signature_failure!; end - def initialize(*names); end - def matches?(actual); end - def matches_arity?(actual, name); end - def pp_names; end - def with(n); end - def with_any_keywords; end - def with_arity; end - def with_arity_string; end - def with_keywords(*keywords); end - def with_keywords_string; end - def with_unlimited_arguments; end -end -class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck - def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end - def matches?(actual, name); end - def method_signature_for(actual, name); end - def verifier_for(actual, name); end -end -class RSpec::Matchers::BuiltIn::Satisfy < RSpec::Matchers::BuiltIn::BaseMatcher - def block_representation; end - def description; end - def extract_block_snippet; end - def failure_message; end - def failure_message_when_negated; end - def initialize(description = nil, &block); end - def matches?(actual, &block); end -end -class RSpec::Matchers::BuiltIn::ThrowSymbol - def actual_result; end - def caught; end - def description; end - def does_not_match?(given_proc); end - def expected(symbol_desc = nil); end - def expects_call_stack_jump?; end - def failure_message; end - def failure_message_when_negated; end - def initialize(expected_symbol = nil, expected_arg = nil); end - def matches?(given_proc); end - def supports_block_expectations?; end - def supports_value_expectations?; end - def throw_description(symbol, arg); end - include RSpec::Matchers::Composable -end -class RSpec::Matchers::BuiltIn::YieldProbe - def assert_used!; end - def assert_valid_expect_block!; end - def has_block?; end - def initialize(block, &callback); end - def num_yields; end - def num_yields=(arg0); end - def probe; end - def self.probe(block, &callback); end - def single_yield_args; end - def to_proc; end - def yielded_args; end - def yielded_args=(arg0); end - def yielded_once?(matcher_name); end -end -class RSpec::Matchers::BuiltIn::YieldControl < RSpec::Matchers::BuiltIn::BaseMatcher - def does_not_match?(block); end - def failure_message; end - def failure_message_when_negated; end - def failure_reason; end - def matches?(block); end - def supports_block_expectations?; end - def supports_value_expectations?; end - include RSpec::Matchers::BuiltIn::CountExpectation -end -class RSpec::Matchers::BuiltIn::YieldWithNoArgs < RSpec::Matchers::BuiltIn::BaseMatcher - def does_not_match?(block); end - def failure_message; end - def failure_message_when_negated; end - def matches?(block); end - def negative_failure_reason; end - def positive_failure_reason; end - def supports_block_expectations?; end - def supports_value_expectations?; end -end -class RSpec::Matchers::BuiltIn::YieldWithArgs < RSpec::Matchers::BuiltIn::BaseMatcher - def all_args_match?; end - def args_currently_match?; end - def description; end - def does_not_match?(block); end - def expected_arg_description; end - def failure_message; end - def failure_message_when_negated; end - def initialize(*args); end - def matches?(block); end - def negative_failure_reason; end - def positive_failure_reason; end - def supports_block_expectations?; end - def supports_value_expectations?; end -end -class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < RSpec::Matchers::BuiltIn::BaseMatcher - def description; end - def does_not_match?(block); end - def expected_arg_description; end - def failure_message; end - def failure_message_when_negated; end - def initialize(*args); end - def matches?(block); end - def negative_failure_reason; end - def positive_failure_reason; end - def supports_block_expectations?; end - def supports_value_expectations?; end -end diff --git a/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi b/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi new file mode 100644 index 00000000..93cfe07f --- /dev/null +++ b/sorbet/rbi/gems/rspec-expectations@3.11.0.rbi @@ -0,0 +1,8180 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rspec-expectations` gem. +# Please instead update this file by running `bin/tapioca gem rspec-expectations`. + +# RSpec's top level namespace. All of rspec-expectations is contained +# in the `RSpec::Expectations` and `RSpec::Matchers` namespaces. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/english_phrasing.rb:1 +module RSpec + class << self + # Used to ensure examples get reloaded between multiple runs in the same + # process and ensures user configuration is persisted. + # + # Users must invoke this if they want to clear all examples but preserve + # current configuration when they use the runner multiple times within the + # same process. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:70 + def clear_examples; end + + # Returns the global [Configuration](RSpec/Core/Configuration) object. While + # you _can_ use this method to access the configuration, the more common + # convention is to use [RSpec.configure](RSpec#configure-class_method). + # + # @example + # RSpec.configuration.drb_port = 1234 + # @see RSpec.configure + # @see Core::Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:85 + def configuration; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def configuration=(_arg0); end + + # Yields the global configuration to a block. + # + # @example + # RSpec.configure do |config| + # config.add_formatter 'documentation' + # end + # @see Core::Configuration + # @yield [Configuration] global configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:97 + def configure; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:194 + def const_missing(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def context(*args, &example_group_block); end + + # The example being executed. + # + # The primary audience for this method is library authors who need access + # to the example currently being executed and also want to support all + # versions of RSpec 2 and 3. + # + # @example + # + # RSpec.configure do |c| + # # context.example is deprecated, but RSpec.current_example is not + # # available until RSpec 3.0. + # fetch_current_example = RSpec.respond_to?(:current_example) ? + # proc { RSpec.current_example } : proc { |context| context.example } + # + # c.before(:example) do + # example = fetch_current_example.call(self) + # + # # ... + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:122 + def current_example; end + + # Set the current example being executed. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:128 + def current_example=(example); end + + # Get the current RSpec execution scope + # + # Returns (in order of lifecycle): + # * `:suite` as an initial value, this is outside of the test lifecycle. + # * `:before_suite_hook` during `before(:suite)` hooks. + # * `:before_context_hook` during `before(:context)` hooks. + # * `:before_example_hook` during `before(:example)` hooks and `around(:example)` before `example.run`. + # * `:example` within the example run. + # * `:after_example_hook` during `after(:example)` hooks and `around(:example)` after `example.run`. + # * `:after_context_hook` during `after(:context)` hooks. + # * `:after_suite_hook` during `after(:suite)` hooks. + # * `:suite` as a final value, again this is outside of the test lifecycle. + # + # Reminder, `:context` hooks have `:all` alias and `:example` hooks have `:each` alias. + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:154 + def current_scope; end + + # Set the current scope rspec is executing in + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:134 + def current_scope=(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def example_group(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fdescribe(*args, &example_group_block); end + + # Used to ensure examples get reloaded and user configuration gets reset to + # defaults between multiple runs in the same process. + # + # Users must invoke this if they want to have the configuration reset when + # they use the runner multiple times within the same process. Users must deal + # themselves with re-configuration of RSpec before run. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:58 + def reset; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_context(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples_for(name, *args, &block); end + + # Internal container for global non-configuration data. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:160 + def world; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def world=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xdescribe(*args, &example_group_block); end + end +end + +# RSpec::Expectations provides a simple, readable API to express +# the expected outcomes in a code example. To express an expected +# outcome, wrap an object or block in `expect`, call `to` or `to_not` +# (aliased as `not_to`) and pass it a matcher object: +# +# expect(order.total).to eq(Money.new(5.55, :USD)) +# expect(list).to include(user) +# expect(message).not_to match(/foo/) +# expect { do_something }.to raise_error +# +# The last form (the block form) is needed to match against ruby constructs +# that are not objects, but can only be observed when executing a block +# of code. This includes raising errors, throwing symbols, yielding, +# and changing values. +# +# When `expect(...).to` is invoked with a matcher, it turns around +# and calls `matcher.matches?(<object wrapped by expect>)`. For example, +# in the expression: +# +# expect(order.total).to eq(Money.new(5.55, :USD)) +# +# ...`eq(Money.new(5.55, :USD))` returns a matcher object, and it results +# in the equivalent of `eq.matches?(order.total)`. If `matches?` returns +# `true`, the expectation is met and execution continues. If `false`, then +# the spec fails with the message returned by `eq.failure_message`. +# +# Given the expression: +# +# expect(order.entries).not_to include(entry) +# +# ...the `not_to` method (also available as `to_not`) invokes the equivalent of +# `include.matches?(order.entries)`, but it interprets `false` as success, and +# `true` as a failure, using the message generated by +# `include.failure_message_when_negated`. +# +# rspec-expectations ships with a standard set of useful matchers, and writing +# your own matchers is quite simple. +# +# See [RSpec::Matchers](../RSpec/Matchers) for more information about the +# built-in matchers that ship with rspec-expectations, and how to write your +# own custom matchers. +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:2 +module RSpec::Expectations + class << self + # The configuration object. + # + # @return [RSpec::Expectations::Configuration] the configuration object + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:223 + def configuration; end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/fail_with.rb:13 + def differ; end + + # Raises an RSpec::Expectations::ExpectationNotMetError with message. + # Adds a diff to the failure message when `expected` and `actual` are + # both present. + # + # @param message [String] + # @param expected [Object] + # @param actual [Object] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/fail_with.rb:27 + def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end + end +end + +# Validates the provided matcher to ensure it supports block +# expectations, in order to avoid user confusion when they +# use a block thinking the expectation will be on the return +# value of the block rather than the block itself. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:136 +class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:142 + def not_to(matcher, message = T.unsafe(nil), &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:137 + def to(matcher, message = T.unsafe(nil), &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:142 + def to_not(matcher, message = T.unsafe(nil), &block); end + + private + + # @raise [ExpectationNotMetError] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:150 + def enforce_block_expectation(matcher); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:158 + def supports_block_expectations?(matcher); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:4 +class RSpec::Expectations::BlockSnippetExtractor + # @return [BlockSnippetExtractor] a new instance of BlockSnippetExtractor + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:17 + def initialize(proc, method_name); end + + # Ideally we should properly handle indentations of multiline snippet, + # but it's not implemented yet since because we use result of this method only when it's a + # single line and implementing the logic introduces additional complexity. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:25 + def body_content_lines; end + + # rubocop should properly handle `Struct.new {}` as an inner class definition. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:7 + def method_name; end + + # rubocop should properly handle `Struct.new {}` as an inner class definition. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:7 + def proc; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:60 + def beginning_line_number; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:39 + def block_token_extractor; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:56 + def file_path; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:31 + def raw_body_lines; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:35 + def raw_body_snippet; end + + # @raise [TargetNotFoundError] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:44 + def source; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:64 + def source_location; end + + class << self + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:9 + def try_extracting_single_line_body_of(proc, method_name); end + end +end + +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:70 +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end + +# Locates target block with node information (semantics), which tokens don't have. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:198 +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct + # Returns the value of attribute beginning_line_number + # + # @return [Object] the current value of beginning_line_number + def beginning_line_number; end + + # Sets the attribute beginning_line_number + # + # @param value [Object] the value to set the attribute beginning_line_number to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:198 + def beginning_line_number=(_); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:203 + def body_content_locations; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:199 + def method_call_location; end + + # Returns the value of attribute method_name + # + # @return [Object] the current value of method_name + def method_name; end + + # Sets the attribute method_name + # + # @param value [Object] the value to set the attribute method_name to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:198 + def method_name=(_); end + + # Returns the value of attribute source + # + # @return [Object] the current value of source + def source; end + + # Sets the attribute source + # + # @param value [Object] the value to set the attribute source to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:198 + def source=(_); end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:216 + def block_body_node; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:221 + def block_wrapper_node; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:232 + def candidate_block_wrapper_nodes; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:241 + def candidate_method_ident_nodes; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:209 + def method_ident_node; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:247 + def method_ident_node?(node); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Performs extraction of block body snippet using tokens, +# which cannot be done with node information. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:75 +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct + # @return [BlockTokenExtractor] a new instance of BlockTokenExtractor + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:78 + def initialize(*_arg0); end + + # Returns the value of attribute beginning_line_number + # + # @return [Object] the current value of beginning_line_number + def beginning_line_number; end + + # Sets the attribute beginning_line_number + # + # @param value [Object] the value to set the attribute beginning_line_number to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:75 + def beginning_line_number=(_); end + + # Returns the value of attribute body_tokens. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:76 + def body_tokens; end + + # Returns the value of attribute method_name + # + # @return [Object] the current value of method_name + def method_name; end + + # Sets the attribute method_name + # + # @param value [Object] the value to set the attribute method_name to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:75 + def method_name=(_); end + + # Returns the value of attribute source + # + # @return [Object] the current value of source + def source; end + + # Sets the attribute source + # + # @param value [Object] the value to set the attribute source to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:75 + def source=(_); end + + # Returns the value of attribute state. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:76 + def state; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:124 + def after_beginning_of_args_state(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:128 + def after_beginning_of_body_state(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:107 + def after_method_call_state(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:111 + def after_opener_state(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:191 + def block_locator; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:185 + def correct_block?(body_tokens); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:141 + def finalize_pending_tokens!; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:95 + def finish!; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:147 + def finish_or_find_next_block_if_incorrect!; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:168 + def handle_closer_token(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:158 + def handle_opener_token(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:103 + def initial_state(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:99 + def invoke_state_handler(token); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:164 + def opener_token?(token); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:177 + def opener_token_stack; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:85 + def parse!; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:137 + def pending_tokens; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:181 + def pipe_token?(token); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:68 +class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end + +# source://rspec-expectations-3.11.0/lib/rspec/expectations/block_snippet_extractor.rb:69 +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end + +# Provides configuration options for rspec-expectations. +# If you are using rspec-core, you can access this via a +# block passed to `RSpec::Core::Configuration#expect_with`. +# Otherwise, you can access it via RSpec::Expectations.configuration. +# +# @example +# RSpec.configure do |rspec| +# rspec.expect_with :rspec do |c| +# # c is the config object +# end +# end +# +# # or +# +# RSpec::Expectations.configuration +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:20 +class RSpec::Expectations::Configuration + # @return [Configuration] a new instance of Configuration + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:29 + def initialize; end + + # Adds `should` and `should_not` to the given classes + # or modules. This can be used to ensure `should` works + # properly on things like proxy objects (particular + # `Delegator`-subclassed objects on 1.8). + # + # @param modules [Array<Module>] the list of classes or modules + # to add `should` and `should_not` to. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:112 + def add_should_and_should_not_to(*modules); end + + # Sets or gets the backtrace formatter. The backtrace formatter should + # implement `#format_backtrace(Array<String>)`. This is used + # to format backtraces of errors handled by the `raise_error` + # matcher. + # + # If you are using rspec-core, rspec-core's backtrace formatting + # will be used (including respecting the presence or absence of + # the `--backtrace` option). + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:129 + def backtrace_formatter; end + + # Sets or gets the backtrace formatter. The backtrace formatter should + # implement `#format_backtrace(Array<String>)`. This is used + # to format backtraces of errors handled by the `raise_error` + # matcher. + # + # If you are using rspec-core, rspec-core's backtrace formatting + # will be used (including respecting the presence or absence of + # the `--backtrace` option). + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:128 + def backtrace_formatter=(_arg0); end + + # Indicates whether or not diffs should be colored. + # Delegates to rspec-core's color option if rspec-core + # is loaded; otherwise you can set it here. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:88 + def color?; end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:216 + def false_positives_handler; end + + # Sets if custom matcher descriptions and failure messages + # should include clauses from methods defined using `chain`. + # + # @param value [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:140 + def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end + + # Indicates whether or not custom matcher descriptions and failure messages + # should include clauses from methods defined using `chain`. It is + # false by default for backwards compatibility. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:145 + def include_chain_clauses_in_custom_matcher_descriptions?; end + + # Configures the maximum character length that RSpec will print while + # formatting an object. You can set length to nil to prevent RSpec from + # doing truncation. + # + # @example + # RSpec.configure do |rspec| + # rspec.expect_with :rspec do |c| + # c.max_formatted_output_length = 200 + # end + # end + # @param length [Fixnum] the number of characters to limit the formatted output to. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:70 + def max_formatted_output_length=(length); end + + # Indicates what RSpec will do about matcher use which will + # potentially cause false positives in tests, generally you want to + # avoid such scenarios so this defaults to `true`. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:206 + def on_potential_false_positives; end + + # Configures what RSpec will do about matcher use which will + # potentially cause false positives in tests. + # + # @param behavior [Symbol] can be set to :warn, :raise or :nothing + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:182 + def on_potential_false_positives=(behavior); end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:150 + def reset_syntaxes_to_default; end + + # Returns the value of attribute strict_predicate_matchers. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:197 + def strict_predicate_matchers; end + + # Configures RSpec to check predicate matchers to `be(true)` / `be(false)` (strict), + # or `be_truthy` / `be_falsey` (not strict). + # Historically, the default was `false`, but `true` is recommended. + # + # @raise [ArgumentError] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:192 + def strict_predicate_matchers=(flag); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:199 + def strict_predicate_matchers?; end + + # The list of configured syntaxes. + # + # @example + # unless RSpec::Matchers.configuration.syntax.include?(:expect) + # raise "this RSpec extension gem requires the rspec-expectations `:expect` syntax" + # end + # @return [Array<Symbol>] the list of configured syntaxes. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:80 + def syntax; end + + # Configures the supported syntax. + # + # @example + # RSpec.configure do |rspec| + # rspec.expect_with :rspec do |c| + # c.syntax = :should + # # or + # c.syntax = :expect + # # or + # c.syntax = [:should, :expect] + # end + # end + # @param values [Array<Symbol>, Symbol] the syntaxes to enable + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:46 + def syntax=(values); end + + # Configures whether RSpec will warn about matcher use which will + # potentially cause false positives in tests. + # + # @param boolean [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:168 + def warn_about_potential_false_positives=(boolean); end + + # Indicates whether RSpec will warn about matcher use which will + # potentially cause false positives in tests, generally you want to + # avoid such scenarios so this defaults to `true`. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:211 + def warn_about_potential_false_positives?; end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:22 +RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash) + +# Null implementation of a backtrace formatter used by default +# when rspec-core is not loaded. Does no filtering. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:158 +module RSpec::Expectations::Configuration::NullBacktraceFormatter + class << self + # source://rspec-expectations-3.11.0/lib/rspec/expectations/configuration.rb:159 + def format_backtrace(backtrace); end + end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:4 +module RSpec::Expectations::ExpectationHelper + class << self + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:5 + def check_message(msg); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:33 + def handle_failure(matcher, message, failure_message_method); end + + # Returns an RSpec-3+ compatible matcher, wrapping a legacy one + # in an adapter if necessary. + # + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:19 + def modern_matcher_from(matcher); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:24 + def with_matcher(handler, matcher, message); end + end +end + +# Exception raised when an expectation fails. +# +# the user sets an expectation, it can't be caught in their +# code by a bare `rescue`. +# +# @api public +# @note We subclass Exception so that in a stub implementation if +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations.rb:67 +class RSpec::Expectations::ExpectationNotMetError < ::Exception; end + +# Wraps the target of an expectation. +# +# @example +# expect(something) # => ExpectationTarget wrapping something +# expect { do_something } # => ExpectationTarget wrapping the block +# +# # used with `to` +# expect(actual).to eq(3) +# +# # with `not_to` +# expect(actual).not_to eq(3) +# @note `ExpectationTarget` is not intended to be instantiated +# directly by users. Use `expect` instead. +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:17 +class RSpec::Expectations::ExpectationTarget + include ::RSpec::Expectations::ExpectationTarget::InstanceMethods + + # @api private + # @return [ExpectationTarget] a new instance of ExpectationTarget + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:31 + def initialize(value); end + + # @note this name aligns with `Minitest::Expectation` so that our + # {InstanceMethods} module can be included in that class when + # used in a Minitest context. + # @return [Object] the target of the expectation + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:28 + def target; end + + class << self + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:36 + def for(value, block); end + end +end + +# Defines instance {ExpectationTarget} instance methods. These are defined +# in a module so we can include it in `Minitest::Expectation` when +# `rspec/expectations/minitest_integration` is loaded in order to +# support usage with Minitest. +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:53 +module RSpec::Expectations::ExpectationTarget::InstanceMethods + # Runs the given expectation, passing if `matcher` returns false. + # + # @example + # expect(value).not_to eq(5) + # @param matcher [Matcher] + # @param message [String, Proc] optional message to display when the expectation fails + # @return [Boolean] false if the negative expectation succeeds (else raises) + # @see RSpec::Matchers + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:76 + def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # Runs the given expectation, passing if `matcher` returns true. + # + # @example + # expect(value).to eq(5) + # expect { perform }.to raise_error + # @param matcher [Matcher] + # @param message [String, Proc] optional message to display when the expectation fails + # @return [Boolean] true if the expectation succeeds (else raises) + # @see RSpec::Matchers + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:63 + def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # Runs the given expectation, passing if `matcher` returns false. + # + # @example + # expect(value).not_to eq(5) + # @param matcher [Matcher] + # @param message [String, Proc] optional message to display when the expectation fails + # @return [Boolean] false if the negative expectation succeeds (else raises) + # @see RSpec::Matchers + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:76 + def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end + + private + + # @raise [ArgumentError] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:84 + def prevent_operator_matchers(verb); end +end + +# Used as a sentinel value to be able to tell when the user +# did not pass an argument. We can't use `nil` for that because +# `nil` is a valid value to pass. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:22 +module RSpec::Expectations::ExpectationTarget::UndefinedValue; end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:4 +class RSpec::Expectations::FailureAggregator + # @return [FailureAggregator] a new instance of FailureAggregator + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:73 + def initialize(block_label, metadata); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:7 + def aggregate; end + + # Returns the value of attribute block_label. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:5 + def block_label; end + + # This method is defined to satisfy the callable interface + # expected by `RSpec::Support.with_failure_notifier`. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:44 + def call(failure, options); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:34 + def failures; end + + # Returns the value of attribute metadata. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:5 + def metadata; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:38 + def other_errors; end + + private + + # Using `caller` performs better (and is simpler) than `raise` on most Rubies. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:68 + def assign_backtrace(failure); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:79 + def notify_aggregated_failures; end +end + +# RSpec 3.0 was released with the class name misspelled. For SemVer compatibility, +# we will provide this misspelled alias until 4.0. +# +# @deprecated Use LegacyMatcherAdapter instead. +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:180 +RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter + +# Wraps a matcher written against one of the legacy protocols in +# order to present the current protocol. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:113 +class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator + # @return [LegacyMatcherAdapter] a new instance of LegacyMatcherAdapter + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:114 + def initialize(matcher); end + + class << self + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:124 + def wrap(matcher); end + end +end + +# Before RSpec 1.2, the failure message protocol was: +# * `failure_message` +# * `negative_failure_message` +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:157 +class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:158 + def failure_message; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:162 + def failure_message_when_negated; end + + class << self + # Note: `failure_message` is part of the RSpec 3 protocol + # (paired with `failure_message_when_negated`), so we don't check + # for `failure_message` here. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:169 + def interface_matches?(matcher); end + end +end + +# Starting in RSpec 1.2 (and continuing through all 2.x releases), +# the failure message protocol was: +# * `failure_message_for_should` +# * `failure_message_for_should_not` +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:133 +class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:134 + def failure_message; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:138 + def failure_message_when_negated; end + + class << self + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:142 + def interface_matches?(matcher); end + end +end + +# Exception raised from `aggregate_failures` when multiple expectations fail. +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations.rb:76 +class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError + # @return [MultipleExpectationsNotMetError] a new instance of MultipleExpectationsNotMetError + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:136 + def initialize(failure_aggregator); end + + # @return [String] The user-assigned label for the aggregation block. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:111 + def aggregation_block_label; end + + # @return [Hash] The metadata hash passed to `aggregate_failures`. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:116 + def aggregation_metadata; end + + # @return [Array<Exception>] The list of expectation failures and other exceptions, combined. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:108 + def all_exceptions; end + + # return [String] A description of the failure/error counts. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:127 + def exception_count_description; end + + # @return [Array<RSpec::Expectations::ExpectationNotMetError>] The list of expectation failures. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:98 + def failures; end + + # @return [String] The fully formatted exception message. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:93 + def message; end + + # @return [Array<Exception>] The list of other exceptions. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:103 + def other_errors; end + + # @return [String] A summary of the failure, including the block label and a count of failures. + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:121 + def summary; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:168 + def backtrace_line(line); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:141 + def block_description; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:150 + def enumerated(exceptions, index_offset); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:180 + def enumerated_errors; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:176 + def enumerated_failures; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:158 + def exclusion_patterns; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:164 + def format_backtrace(backtrace); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:195 + def indentation; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:186 + def indented(failure_message, index); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:207 + def index_label(index); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:199 + def longest_index_label_width; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:146 + def pluralize(noun, count); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/failure_aggregator.rb:203 + def width_of_label(index); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:74 +class RSpec::Expectations::NegativeExpectationHandler + class << self + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:88 + def does_not_match?(matcher, actual, &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:75 + def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:104 + def opposite_should_method; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:100 + def should_method; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:96 + def verb; end + end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:46 +class RSpec::Expectations::PositiveExpectationHandler + class << self + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:47 + def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:68 + def opposite_should_method; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:64 + def should_method; end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/handler.rb:60 + def verb; end + end +end + +# Provides methods for enabling and disabling the available +# syntaxes provided by rspec-expectations. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:6 +module RSpec::Expectations::Syntax + private + + # Determines where we add `should` and `should_not`. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:11 + def default_should_host; end + + # Disables the `expect` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:80 + def disable_expect(syntax_host = T.unsafe(nil)); end + + # Disables the `should` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:57 + def disable_should(syntax_host = T.unsafe(nil)); end + + # Enables the `expect` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:68 + def enable_expect(syntax_host = T.unsafe(nil)); end + + # Enables the `should` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:38 + def enable_should(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the `expect` syntax is enabled. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:96 + def expect_enabled?(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the `should` syntax is enabled. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:90 + def should_enabled?(syntax_host = T.unsafe(nil)); end + + # Instructs rspec-expectations to warn on first usage of `should` or `should_not`. + # Enabled by default. This is largely here to facilitate testing. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:18 + def warn_about_should!; end + + # Generates a deprecation warning for the given method if no warning + # has already been issued. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:25 + def warn_about_should_unless_configured(method_name); end + + class << self + # Determines where we add `should` and `should_not`. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:11 + def default_should_host; end + + # Disables the `expect` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:80 + def disable_expect(syntax_host = T.unsafe(nil)); end + + # Disables the `should` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:57 + def disable_should(syntax_host = T.unsafe(nil)); end + + # Enables the `expect` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:68 + def enable_expect(syntax_host = T.unsafe(nil)); end + + # Enables the `should` syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:38 + def enable_should(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the `expect` syntax is enabled. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:96 + def expect_enabled?(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the `should` syntax is enabled. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:90 + def should_enabled?(syntax_host = T.unsafe(nil)); end + + # Instructs rspec-expectations to warn on first usage of `should` or `should_not`. + # Enabled by default. This is largely here to facilitate testing. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:18 + def warn_about_should!; end + + # Generates a deprecation warning for the given method if no warning + # has already been issued. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:25 + def warn_about_should_unless_configured(method_name); end + end +end + +# Validates the provided matcher to ensure it supports block +# expectations, in order to avoid user confusion when they +# use a block thinking the expectation will be on the return +# value of the block rather than the block itself. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:98 +class RSpec::Expectations::ValueExpectationTarget < ::RSpec::Expectations::ExpectationTarget + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:104 + def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:99 + def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:111 + def enforce_value_expectation(matcher); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/expectation_target.rb:126 + def supports_value_expectations?(matcher); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/expectations/version.rb:4 +module RSpec::Expectations::Version; end + +# source://rspec-expectations-3.11.0/lib/rspec/expectations/version.rb:5 +RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core.rb:187 +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +# RSpec::Matchers provides a number of useful matchers we use to define +# expectations. Any object that implements the [matcher protocol](Matchers/MatcherProtocol) +# can be used as a matcher. +# +# ## Predicates +# +# In addition to matchers that are defined explicitly, RSpec will create +# custom matchers on the fly for any arbitrary predicate, giving your specs a +# much more natural language feel. +# +# A Ruby predicate is a method that ends with a "?" and returns true or false. +# Common examples are `empty?`, `nil?`, and `instance_of?`. +# +# All you need to do is write `expect(..).to be_` followed by the predicate +# without the question mark, and RSpec will figure it out from there. +# For example: +# +# expect([]).to be_empty # => [].empty?() | passes +# expect([]).not_to be_empty # => [].empty?() | fails +# +# In addtion to prefixing the predicate matchers with "be_", you can also use "be_a_" +# and "be_an_", making your specs read much more naturally: +# +# expect("a string").to be_an_instance_of(String) # =>"a string".instance_of?(String) # passes +# +# expect(3).to be_a_kind_of(Integer) # => 3.kind_of?(Numeric) | passes +# expect(3).to be_a_kind_of(Numeric) # => 3.kind_of?(Numeric) | passes +# expect(3).to be_an_instance_of(Integer) # => 3.instance_of?(Integer) | passes +# expect(3).not_to be_an_instance_of(Numeric) # => 3.instance_of?(Numeric) | fails +# +# RSpec will also create custom matchers for predicates like `has_key?`. To +# use this feature, just state that the object should have_key(:key) and RSpec will +# call has_key?(:key) on the target. For example: +# +# expect(:a => "A").to have_key(:a) +# expect(:a => "A").to have_key(:b) # fails +# +# You can use this feature to invoke any predicate that begins with "has_", whether it is +# part of the Ruby libraries (like `Hash#has_key?`) or a method you wrote on your own class. +# +# Note that RSpec does not provide composable aliases for these dynamic predicate +# matchers. You can easily define your own aliases, though: +# +# RSpec::Matchers.alias_matcher :a_user_who_is_an_admin, :be_an_admin +# expect(user_list).to include(a_user_who_is_an_admin) +# +# ## Alias Matchers +# +# With {RSpec::Matchers.alias_matcher}, you can easily create an +# alternate name for a given matcher. +# +# The description will also change according to the new name: +# +# RSpec::Matchers.alias_matcher :a_list_that_sums_to, :sum_to +# sum_to(3).description # => "sum to 3" +# a_list_that_sums_to(3).description # => "a list that sums to 3" +# +# or you can specify a custom description like this: +# +# RSpec::Matchers.alias_matcher :a_list_sorted_by, :be_sorted_by do |description| +# description.sub("be sorted by", "a list sorted by") +# end +# +# be_sorted_by(:age).description # => "be sorted by age" +# a_list_sorted_by(:age).description # => "a list sorted by age" +# +# ## Custom Matchers +# +# When you find that none of the stock matchers provide a natural feeling +# expectation, you can very easily write your own using RSpec's matcher DSL +# or writing one from scratch. +# +# ### Matcher DSL +# +# Imagine that you are writing a game in which players can be in various +# zones on a virtual board. To specify that bob should be in zone 4, you +# could say: +# +# expect(bob.current_zone).to eql(Zone.new("4")) +# +# But you might find it more expressive to say: +# +# expect(bob).to be_in_zone("4") +# +# and/or +# +# expect(bob).not_to be_in_zone("3") +# +# You can create such a matcher like so: +# +# RSpec::Matchers.define :be_in_zone do |zone| +# match do |player| +# player.in_zone?(zone) +# end +# end +# +# This will generate a <tt>be_in_zone</tt> method that returns a matcher +# with logical default messages for failures. You can override the failure +# messages and the generated description as follows: +# +# RSpec::Matchers.define :be_in_zone do |zone| +# match do |player| +# player.in_zone?(zone) +# end +# +# failure_message do |player| +# # generate and return the appropriate string. +# end +# +# failure_message_when_negated do |player| +# # generate and return the appropriate string. +# end +# +# description do +# # generate and return the appropriate string. +# end +# end +# +# Each of the message-generation methods has access to the block arguments +# passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The +# failure message methods (<tt>failure_message</tt> and +# <tt>failure_message_when_negated</tt>) are passed the actual value (the +# receiver of <tt>expect(..)</tt> or <tt>expect(..).not_to</tt>). +# +# ### Custom Matcher from scratch +# +# You could also write a custom matcher from scratch, as follows: +# +# class BeInZone +# def initialize(expected) +# @expected = expected +# end +# +# def matches?(target) +# @target = target +# @target.current_zone.eql?(Zone.new(@expected)) +# end +# +# def failure_message +# "expected #{@target.inspect} to be in Zone #{@expected}" +# end +# +# def failure_message_when_negated +# "expected #{@target.inspect} not to be in Zone #{@expected}" +# end +# end +# +# ... and a method like this: +# +# def be_in_zone(expected) +# BeInZone.new(expected) +# end +# +# And then expose the method to your specs. This is normally done +# by including the method and the class in a module, which is then +# included in your spec: +# +# module CustomGameMatchers +# class BeInZone +# # ... +# end +# +# def be_in_zone(expected) +# # ... +# end +# end +# +# describe "Player behaviour" do +# include CustomGameMatchers +# # ... +# end +# +# or you can include in globally in a spec_helper.rb file <tt>require</tt>d +# from your spec file(s): +# +# RSpec::configure do |config| +# config.include(CustomGameMatchers) +# end +# +# ### Making custom matchers composable +# +# RSpec's built-in matchers are designed to be composed, in expressions like: +# +# expect(["barn", 2.45]).to contain_exactly( +# a_value_within(0.1).of(2.5), +# a_string_starting_with("bar") +# ) +# +# Custom matchers can easily participate in composed matcher expressions like these. +# Include {RSpec::Matchers::Composable} in your custom matcher to make it support +# being composed (matchers defined using the DSL have this included automatically). +# Within your matcher's `matches?` method (or the `match` block, if using the DSL), +# use `values_match?(expected, actual)` rather than `expected == actual`. +# Under the covers, `values_match?` is able to match arbitrary +# nested data structures containing a mix of both matchers and non-matcher objects. +# It uses `===` and `==` to perform the matching, considering the values to +# match if either returns `true`. The `Composable` mixin also provides some helper +# methods for surfacing the matcher descriptions within your matcher's description +# or failure messages. +# +# RSpec's built-in matchers each have a number of aliases that rephrase the matcher +# from a verb phrase (such as `be_within`) to a noun phrase (such as `a_value_within`), +# which reads better when the matcher is passed as an argument in a composed matcher +# expressions, and also uses the noun-phrase wording in the matcher's `description`, +# for readable failure messages. You can alias your custom matchers in similar fashion +# using {RSpec::Matchers.alias_matcher}. +# +# ## Negated Matchers +# +# Sometimes if you want to test for the opposite using a more descriptive name +# instead of using `not_to`, you can use {RSpec::Matchers.define_negated_matcher}: +# +# RSpec::Matchers.define_negated_matcher :exclude, :include +# include(1, 2).description # => "include 1 and 2" +# exclude(1, 2).description # => "exclude 1 and 2" +# +# While the most obvious negated form may be to add a `not_` prefix, +# the failure messages you get with that form can be confusing (e.g. +# "expected [actual] to not [verb], but did not"). We've found it works +# best to find a more positive name for the negated form, such as +# `avoid_changing` rather than `not_change`. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/english_phrasing.rb:2 +module RSpec::Matchers + extend ::RSpec::Matchers::DSL + + # Applied to a proc, specifies that its execution will cause some value to + # change. + # + # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block, + # but not both. + # + # When passing a block, it must use the `{ ... }` format, not + # do/end, as `{ ... }` binds to the `change` method, whereas do/end + # would errantly bind to the `expect(..).to` or `expect(...).not_to` method. + # + # You can chain any of the following off of the end to specify details + # about the change: + # + # * `from` + # * `to` + # + # or any one of: + # + # * `by` + # * `by_at_least` + # * `by_at_most` + # + # == Notes + # + # Evaluates `receiver.message` or `block` before and after it + # evaluates the block passed to `expect`. If the value is the same + # object, its before/after `hash` value is used to see if it has changed. + # Therefore, your object needs to properly implement `hash` to work correctly + # with this matcher. + # + # `expect( ... ).not_to change` supports the form that specifies `from` + # (which specifies what you expect the starting, unchanged value to be) + # but does not support forms with subsequent calls to `by`, `by_at_least`, + # `by_at_most` or `to`. + # + # @example + # expect { + # team.add_player(player) + # }.to change(roster, :count) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_least(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_most(1) + # + # string = "string" + # expect { + # string.reverse! + # }.to change { string }.from("string").to("gnirts") + # + # string = "string" + # expect { + # string + # }.not_to change { string }.from("string") + # + # expect { + # person.happy_birthday + # }.to change(person, :birthday).from(32).to(33) + # + # expect { + # employee.develop_great_new_social_networking_app + # }.to change(employee, :title).from("Mail Clerk").to("CEO") + # + # expect { + # doctor.leave_office + # }.to change(doctor, :sign).from(/is in/).to(/is out/) + # + # user = User.new(:type => "admin") + # expect { + # user.symbolize_type + # }.to change(user, :type).from(String).to(Symbol) + # @param receiver [Object] + # @param message [Symbol] the message to send the receiver + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_changing(*args, &block); end + + # With no arg, passes if the block outputs `to_stdout` or `to_stderr`. + # With a string, passes if the block outputs that specific string `to_stdout` or `to_stderr`. + # With a regexp or matcher, passes if the block outputs a string `to_stdout` or `to_stderr` that matches. + # + # To capture output from any spawned subprocess as well, use `to_stdout_from_any_process` or + # `to_stderr_from_any_process`. Output from any process that inherits the main process's corresponding + # standard stream will be captured. + # + # @example + # expect { print 'foo' }.to output.to_stdout + # expect { print 'foo' }.to output('foo').to_stdout + # expect { print 'foo' }.to output(/foo/).to_stdout + # + # expect { do_something }.to_not output.to_stdout + # + # expect { warn('foo') }.to output.to_stderr + # expect { warn('foo') }.to output('foo').to_stderr + # expect { warn('foo') }.to output(/foo/).to_stderr + # + # expect { do_something }.to_not output.to_stderr + # + # expect { system('echo foo') }.to output("foo\n").to_stdout_from_any_process + # expect { system('echo foo', out: :err) }.to output("foo\n").to_stderr_from_any_process + # @note `to_stdout` and `to_stderr` work by temporarily replacing `$stdout` or `$stderr`, + # so they're not able to intercept stream output that explicitly uses `STDOUT`/`STDERR` + # or that uses a reference to `$stdout`/`$stderr` that was stored before the + # matcher was used. + # @note `to_stdout_from_any_process` and `to_stderr_from_any_process` use Tempfiles, and + # are thus significantly (~30x) slower than `to_stdout` and `to_stderr`. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_outputting(*args, &block); end + + # With no args, matches if any error is raised. + # With a named error, matches only if that specific error is raised. + # With a named error and messsage specified as a String, matches only if both match. + # With a named error and messsage specified as a Regexp, matches only if both match. + # Pass an optional block to perform extra verifications on the exception matched + # + # @example + # expect { do_something_risky }.to raise_error + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky") + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/) + # expect { do_something_risky }.to raise_error("that was too risky") + # + # expect { do_something_risky }.not_to raise_error + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_raising(*args, &block); end + + # Given no argument, matches if a proc throws any Symbol. + # + # Given a Symbol, matches if the given proc throws the specified Symbol. + # + # Given a Symbol and an arg, matches if the given proc throws the + # specified Symbol with the specified arg. + # + # @example + # expect { do_something_risky }.to throw_symbol + # expect { do_something_risky }.to throw_symbol(:that_was_risky) + # expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit') + # + # expect { do_something_risky }.not_to throw_symbol + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky) + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit') + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_throwing(*args, &block); end + + # Passes if the method called in the expect block yields, regardless + # of whether or not arguments are yielded. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_control + # expect { |b| "a".to_sym(&b) }.not_to yield_control + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_yielding_control(*args, &block); end + + # Designed for use with methods that repeatedly yield (such as + # iterators). Passes if the method called in the expect block yields + # multiple times with arguments matching those given. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3) + # expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2]) + # expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_yielding_successive_args(*args, &block); end + + # Given no arguments, matches if the method called in the expect + # block yields with arguments (regardless of what they are or how + # many there are). + # + # Given arguments, matches if the method called in the expect block + # yields with arguments that match the given arguments. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg + # expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5 + # expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5 + # expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt" + # + # expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args + # expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_yielding_with_args(*args, &block); end + + # Passes if the method called in the expect block yields with + # no arguments. Fails if it does not yield, or yields with arguments. + # + # @example + # expect { |b| User.transaction(&b) }.to yield_with_no_args + # expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5` + # expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_block_yielding_with_no_args(*args, &block); end + + # Passes if actual contains all of the expected regardless of order. + # This works for collections. Pass in multiple args and it will only + # pass if all args are found in collection. + # + # @example + # expect([1, 2, 3]).to contain_exactly(1, 2, 3) + # expect([1, 2, 3]).to contain_exactly(1, 3, 2) + # @note This is also available using the `=~` operator with `should`, + # but `=~` is not supported with `expect`. + # @see #match_array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_collection_containing_exactly(*args, &block); end + + # Matches if the actual value ends with the expected value(s). In the case + # of a string, matches against the last `expected.length` characters of the + # actual string. In the case of an array, matches against the last + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to end_with "string" + # expect([0, 1, 2, 3, 4]).to end_with 4 + # expect([0, 2, 3, 4, 4]).to end_with 3, 4 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_collection_ending_with(*args, &block); end + + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # @example + # expect([1,2,3]).to include(3) + # expect([1,2,3]).to include(2,3) + # expect([1,2,3]).to include(2,3,4) # fails + # expect([1,2,3]).not_to include(4) + # expect("spread").to include("read") + # expect("spread").not_to include("red") + # expect(:a => 1, :b => 2).to include(:a) + # expect(:a => 1, :b => 2).to include(:a, :b) + # expect(:a => 1, :b => 2).to include(:a => 1) + # expect(:a => 1, :b => 2).to include(:b => 2, :a => 1) + # expect(:a => 1, :b => 2).to include(:c) # fails + # expect(:a => 1, :b => 2).not_to include(:a => 2) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_collection_including(*args, &block); end + + # Matches if the actual value starts with the expected value(s). In the + # case of a string, matches against the first `expected.length` characters + # of the actual string. In the case of an array, matches against the first + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to start_with "this s" + # expect([0, 1, 2, 3, 4]).to start_with 0 + # expect([0, 2, 3, 4, 4]).to start_with 0, 1 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_collection_starting_with(*args, &block); end + + # Passes if actual is falsey (false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_falsey_value(*args, &block); end + + # Passes if actual is falsey (false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_falsy_value(*args, &block); end + + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # @example + # expect([1,2,3]).to include(3) + # expect([1,2,3]).to include(2,3) + # expect([1,2,3]).to include(2,3,4) # fails + # expect([1,2,3]).not_to include(4) + # expect("spread").to include("read") + # expect("spread").not_to include("red") + # expect(:a => 1, :b => 2).to include(:a) + # expect(:a => 1, :b => 2).to include(:a, :b) + # expect(:a => 1, :b => 2).to include(:a => 1) + # expect(:a => 1, :b => 2).to include(:b => 2, :a => 1) + # expect(:a => 1, :b => 2).to include(:c) # fails + # expect(:a => 1, :b => 2).not_to include(:a => 2) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_hash_including(*args, &block); end + + # Passes if actual.kind_of?(expected) + # + # @example + # expect(5).to be_a_kind_of(Integer) + # expect(5).to be_a_kind_of(Numeric) + # expect(5).not_to be_a_kind_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_kind_of(*args, &block); end + + # Passes if actual is nil + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_nil_value(*args, &block); end + + # Passes if actual covers expected. This works for + # Ranges. You can also pass in multiple args + # and it will only pass if all args are found in Range. + # + # ### Warning:: Ruby >= 1.9 only + # + # @example + # expect(1..10).to cover(5) + # expect(1..10).to cover(4, 6) + # expect(1..10).to cover(4, 6, 11) # fails + # expect(1..10).not_to cover(11) + # expect(1..10).not_to cover(5) # fails + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_range_covering(*args, &block); end + + # Matches if the actual value ends with the expected value(s). In the case + # of a string, matches against the last `expected.length` characters of the + # actual string. In the case of an array, matches against the last + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to end_with "string" + # expect([0, 1, 2, 3, 4]).to end_with 4 + # expect([0, 2, 3, 4, 4]).to end_with 3, 4 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_string_ending_with(*args, &block); end + + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # @example + # expect([1,2,3]).to include(3) + # expect([1,2,3]).to include(2,3) + # expect([1,2,3]).to include(2,3,4) # fails + # expect([1,2,3]).not_to include(4) + # expect("spread").to include("read") + # expect("spread").not_to include("red") + # expect(:a => 1, :b => 2).to include(:a) + # expect(:a => 1, :b => 2).to include(:a, :b) + # expect(:a => 1, :b => 2).to include(:a => 1) + # expect(:a => 1, :b => 2).to include(:b => 2, :a => 1) + # expect(:a => 1, :b => 2).to include(:c) # fails + # expect(:a => 1, :b => 2).not_to include(:a => 2) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_string_including(*args, &block); end + + # Given a `Regexp` or `String`, passes if `actual.match(pattern)` + # Given an arbitrary nested data structure (e.g. arrays and hashes), + # matches if `expected === actual` || `actual == expected` for each + # pair of elements. + # + # @example + # expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # expect(email).to match("@example.com") + # @example + # hash = { + # :a => { + # :b => ["foo", 5], + # :c => { :d => 2.05 } + # } + # } + # + # expect(hash).to match( + # :a => { + # :b => a_collection_containing_exactly( + # a_string_starting_with("f"), + # an_instance_of(Integer) + # ), + # :c => { :d => (a_value < 3) } + # } + # ) + # @note The `match_regex` alias is deprecated and is not recommended for use. + # It was added in 2.12.1 to facilitate its use from within custom + # matchers (due to how the custom matcher DSL was evaluated in 2.x, + # `match` could not be used there), but is no longer needed in 3.x. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_string_matching(*args, &block); end + + # Matches if the actual value starts with the expected value(s). In the + # case of a string, matches against the first `expected.length` characters + # of the actual string. In the case of an array, matches against the first + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to start_with "this s" + # expect([0, 1, 2, 3, 4]).to start_with 0 + # expect([0, 2, 3, 4, 4]).to start_with 0, 1 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_string_starting_with(*args, &block); end + + # Passes if actual is truthy (anything but false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_truthy_value(*args, &block); end + + # Given true, false, or nil, will pass if actual value is true, false or + # nil (respectively). Given no args means the caller should satisfy an if + # condition (to be or not to be). + # + # Predicates are any Ruby method that ends in a "?" and returns true or + # false. Given be_ followed by arbitrary_predicate (without the "?"), + # RSpec will match convert that into a query against the target object. + # + # The arbitrary_predicate feature will handle any predicate prefixed with + # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_" + # (e.g. be_empty), letting you choose the prefix that best suits the + # predicate. + # + # @example + # expect(actual).to be_truthy + # expect(actual).to be_falsey + # expect(actual).to be_nil + # expect(actual).to be_[arbitrary_predicate](*args) + # expect(actual).not_to be_nil + # expect(actual).not_to be_[arbitrary_predicate](*args) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_value(*args, &block); end + + # Passes if actual.between?(min, max). Works with any Comparable object, + # including String, Symbol, Time, or Numeric (Fixnum, Bignum, Integer, + # Float, Complex, and Rational). + # + # By default, `be_between` is inclusive (i.e. passes when given either the max or min value), + # but you can make it `exclusive` by chaining that off the matcher. + # + # @example + # expect(5).to be_between(1, 10) + # expect(11).not_to be_between(1, 10) + # expect(10).not_to be_between(1, 10).exclusive + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_value_between(*args, &block); end + + # Passes if actual == expected +/- delta + # + # @example + # expect(result).to be_within(0.5).of(3.0) + # expect(result).not_to be_within(0.5).of(3.0) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def a_value_within(*args, &block); end + + # Allows multiple expectations in the provided block to fail, and then + # aggregates them into a single exception, rather than aborting on the + # first expectation failure like normal. This allows you to see all + # failures from an entire set of expectations without splitting each + # off into its own example (which may slow things down if the example + # setup is expensive). + # + # @example + # aggregate_failures("verifying response") do + # expect(response.status).to eq(200) + # expect(response.headers).to include("Content-Type" => "text/plain") + # expect(response.body).to include("Success") + # end + # @note The implementation of this feature uses a thread-local variable, + # which means that if you have an expectation failure in another thread, + # it'll abort like normal. + # @param label [String] label for this aggregation block, which will be + # included in the aggregated exception message. + # @param metadata [Hash] additional metadata about this failure aggregation + # block. If multiple expectations fail, it will be exposed from the + # {Expectations::MultipleExpectationsNotMetError} exception. Mostly + # intended for internal RSpec use but you can use it as well. + # @raise [Expectations::MultipleExpectationsNotMetError] raised when + # multiple expectations fail. + # @raise [Expectations::ExpectationNotMetError] raised when a single + # expectation fails. + # @raise [Exception] other sorts of exceptions will be raised as normal. + # @yield Block containing as many expectation as you want. The block is + # simply yielded to, so you can trust that anything that works outside + # the block should work within it. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:305 + def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end + + # Passes if the provided matcher passes when checked against all + # elements of the collection. + # + # @example + # expect([1, 3, 5]).to all be_odd + # expect([1, 3, 6]).to all be_odd # fails + # @example + # expect([1, 3, 5]).to all( be_odd.and be_an(Integer) ) + # @note The negative form `not_to all` is not supported. Instead + # use `not_to include` or pass a negative form of a matcher + # as the argument (e.g. `all exclude(:foo)`). + # @note You can also use this with compound matchers as well. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:662 + def all(expected); end + + # Passes if actual.instance_of?(expected) + # + # @example + # expect(5).to be_an_instance_of(Integer) + # expect(5).not_to be_an_instance_of(Numeric) + # expect(5).not_to be_an_instance_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_instance_of(*args, &block); end + + # Passes if <tt>actual == expected</tt>. + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eq(5) + # expect(5).not_to eq(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_eq_to(*args, &block); end + + # Passes if `actual.eql?(expected)` + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eql(5) + # expect(5).not_to eql(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_eql_to(*args, &block); end + + # Passes if <tt>actual.equal?(expected)</tt> (object identity). + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to equal(5) # Integers are equal + # expect("5").not_to equal("5") # Strings that look the same are not the same object + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_equal_to(*args, &block); end + + # Passes if `actual.exist?` or `actual.exists?` + # + # @example + # expect(File).to exist("path/to/file") + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_existing(*args, &block); end + + # Passes if actual's attribute values match the expected attributes hash. + # This works no matter how you define your attribute readers. + # + # @example + # Person = Struct.new(:name, :age) + # person = Person.new("Bob", 32) + # + # expect(person).to have_attributes(:name => "Bob", :age => 32) + # expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) ) + # @example + # expect(person).to have_attributes(:color => "red") + # @note It will fail if actual doesn't respond to any of the expected attributes. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_having_attributes(*args, &block); end + + # Given a `Regexp` or `String`, passes if `actual.match(pattern)` + # Given an arbitrary nested data structure (e.g. arrays and hashes), + # matches if `expected === actual` || `actual == expected` for each + # pair of elements. + # + # @example + # expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # expect(email).to match("@example.com") + # @example + # hash = { + # :a => { + # :b => ["foo", 5], + # :c => { :d => 2.05 } + # } + # } + # + # expect(hash).to match( + # :a => { + # :b => a_collection_containing_exactly( + # a_string_starting_with("f"), + # an_instance_of(Integer) + # ), + # :c => { :d => (a_value < 3) } + # } + # ) + # @note The `match_regex` alias is deprecated and is not recommended for use. + # It was added in 2.12.1 to facilitate its use from within custom + # matchers (due to how the custom matcher DSL was evaluated in 2.x, + # `match` could not be used there), but is no longer needed in 3.x. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_matching(*args, &block); end + + # Matches if the target object responds to all of the names + # provided. Names can be Strings or Symbols. + # + # @example + # expect("string").to respond_to(:length) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_responding_to(*args, &block); end + + # Passes if the submitted block returns true. Yields target to the + # block. + # + # Generally speaking, this should be thought of as a last resort when + # you can't find any other way to specify the behaviour you wish to + # specify. + # + # If you do find yourself in such a situation, you could always write + # a custom matcher, which would likely make your specs more expressive. + # + # @example + # expect(5).to satisfy { |n| n > 3 } + # expect(5).to satisfy("be greater than 3") { |n| n > 3 } + # @param description [String] optional description to be used for this matcher. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def an_object_satisfying(*args, &block); end + + # Given true, false, or nil, will pass if actual value is true, false or + # nil (respectively). Given no args means the caller should satisfy an if + # condition (to be or not to be). + # + # Predicates are any Ruby method that ends in a "?" and returns true or + # false. Given be_ followed by arbitrary_predicate (without the "?"), + # RSpec will match convert that into a query against the target object. + # + # The arbitrary_predicate feature will handle any predicate prefixed with + # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_" + # (e.g. be_empty), letting you choose the prefix that best suits the + # predicate. + # + # @example + # expect(actual).to be_truthy + # expect(actual).to be_falsey + # expect(actual).to be_nil + # expect(actual).to be_[arbitrary_predicate](*args) + # expect(actual).not_to be_nil + # expect(actual).not_to be_[arbitrary_predicate](*args) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:349 + def be(*args); end + + # passes if target.kind_of?(klass) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:355 + def be_a(klass); end + + # Passes if actual.kind_of?(expected) + # + # @example + # expect(5).to be_a_kind_of(Integer) + # expect(5).to be_a_kind_of(Numeric) + # expect(5).not_to be_a_kind_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:378 + def be_a_kind_of(expected); end + + # passes if target.kind_of?(klass) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:355 + def be_an(klass); end + + # Passes if actual.instance_of?(expected) + # + # @example + # expect(5).to be_an_instance_of(Integer) + # expect(5).not_to be_an_instance_of(Numeric) + # expect(5).not_to be_an_instance_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:366 + def be_an_instance_of(expected); end + + # Passes if actual.between?(min, max). Works with any Comparable object, + # including String, Symbol, Time, or Numeric (Fixnum, Bignum, Integer, + # Float, Complex, and Rational). + # + # By default, `be_between` is inclusive (i.e. passes when given either the max or min value), + # but you can make it `exclusive` by chaining that off the matcher. + # + # @example + # expect(5).to be_between(1, 10) + # expect(11).not_to be_between(1, 10) + # expect(10).not_to be_between(1, 10).exclusive + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:395 + def be_between(min, max); end + + # Passes if actual is falsey (false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:316 + def be_falsey; end + + # Passes if actual is falsey (false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def be_falsy(*args, &block); end + + # Passes if actual.instance_of?(expected) + # + # @example + # expect(5).to be_an_instance_of(Integer) + # expect(5).not_to be_an_instance_of(Numeric) + # expect(5).not_to be_an_instance_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:366 + def be_instance_of(expected); end + + # Passes if actual.kind_of?(expected) + # + # @example + # expect(5).to be_a_kind_of(Integer) + # expect(5).to be_a_kind_of(Numeric) + # expect(5).not_to be_a_kind_of(Float) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:378 + def be_kind_of(expected); end + + # Passes if actual is nil + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:324 + def be_nil; end + + # Passes if actual is truthy (anything but false or nil) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:310 + def be_truthy; end + + # Passes if actual == expected +/- delta + # + # @example + # expect(result).to be_within(0.5).of(3.0) + # expect(result).not_to be_within(0.5).of(3.0) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:405 + def be_within(delta); end + + # Applied to a proc, specifies that its execution will cause some value to + # change. + # + # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block, + # but not both. + # + # When passing a block, it must use the `{ ... }` format, not + # do/end, as `{ ... }` binds to the `change` method, whereas do/end + # would errantly bind to the `expect(..).to` or `expect(...).not_to` method. + # + # You can chain any of the following off of the end to specify details + # about the change: + # + # * `from` + # * `to` + # + # or any one of: + # + # * `by` + # * `by_at_least` + # * `by_at_most` + # + # == Notes + # + # Evaluates `receiver.message` or `block` before and after it + # evaluates the block passed to `expect`. If the value is the same + # object, its before/after `hash` value is used to see if it has changed. + # Therefore, your object needs to properly implement `hash` to work correctly + # with this matcher. + # + # `expect( ... ).not_to change` supports the form that specifies `from` + # (which specifies what you expect the starting, unchanged value to be) + # but does not support forms with subsequent calls to `by`, `by_at_least`, + # `by_at_most` or `to`. + # + # @example + # expect { + # team.add_player(player) + # }.to change(roster, :count) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_least(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_most(1) + # + # string = "string" + # expect { + # string.reverse! + # }.to change { string }.from("string").to("gnirts") + # + # string = "string" + # expect { + # string + # }.not_to change { string }.from("string") + # + # expect { + # person.happy_birthday + # }.to change(person, :birthday).from(32).to(33) + # + # expect { + # employee.develop_great_new_social_networking_app + # }.to change(employee, :title).from("Mail Clerk").to("CEO") + # + # expect { + # doctor.leave_office + # }.to change(doctor, :sign).from(/is in/).to(/is out/) + # + # user = User.new(:type => "admin") + # expect { + # user.symbolize_type + # }.to change(user, :type).from(String).to(Symbol) + # @param receiver [Object] + # @param message [Symbol] the message to send the receiver + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:492 + def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # Applied to a proc, specifies that its execution will cause some value to + # change. + # + # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block, + # but not both. + # + # When passing a block, it must use the `{ ... }` format, not + # do/end, as `{ ... }` binds to the `change` method, whereas do/end + # would errantly bind to the `expect(..).to` or `expect(...).not_to` method. + # + # You can chain any of the following off of the end to specify details + # about the change: + # + # * `from` + # * `to` + # + # or any one of: + # + # * `by` + # * `by_at_least` + # * `by_at_most` + # + # == Notes + # + # Evaluates `receiver.message` or `block` before and after it + # evaluates the block passed to `expect`. If the value is the same + # object, its before/after `hash` value is used to see if it has changed. + # Therefore, your object needs to properly implement `hash` to work correctly + # with this matcher. + # + # `expect( ... ).not_to change` supports the form that specifies `from` + # (which specifies what you expect the starting, unchanged value to be) + # but does not support forms with subsequent calls to `by`, `by_at_least`, + # `by_at_most` or `to`. + # + # @example + # expect { + # team.add_player(player) + # }.to change(roster, :count) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_least(1) + # + # expect { + # team.add_player(player) + # }.to change(roster, :count).by_at_most(1) + # + # string = "string" + # expect { + # string.reverse! + # }.to change { string }.from("string").to("gnirts") + # + # string = "string" + # expect { + # string + # }.not_to change { string }.from("string") + # + # expect { + # person.happy_birthday + # }.to change(person, :birthday).from(32).to(33) + # + # expect { + # employee.develop_great_new_social_networking_app + # }.to change(employee, :title).from("Mail Clerk").to("CEO") + # + # expect { + # doctor.leave_office + # }.to change(doctor, :sign).from(/is in/).to(/is out/) + # + # user = User.new(:type => "admin") + # expect { + # user.symbolize_type + # }.to change(user, :type).from(String).to(Symbol) + # @param receiver [Object] + # @param message [Symbol] the message to send the receiver + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def changing(*args, &block); end + + # Passes if actual contains all of the expected regardless of order. + # This works for collections. Pass in multiple args and it will only + # pass if all args are found in collection. + # + # @example + # expect([1, 2, 3]).to contain_exactly(1, 2, 3) + # expect([1, 2, 3]).to contain_exactly(1, 3, 2) + # @note This is also available using the `=~` operator with `should`, + # but `=~` is not supported with `expect`. + # @see #match_array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:510 + def contain_exactly(*items); end + + # Passes if actual contains all of the expected regardless of order. + # This works for collections. Pass in multiple args and it will only + # pass if all args are found in collection. + # + # @example + # expect([1, 2, 3]).to contain_exactly(1, 2, 3) + # expect([1, 2, 3]).to contain_exactly(1, 3, 2) + # @note This is also available using the `=~` operator with `should`, + # but `=~` is not supported with `expect`. + # @see #match_array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def containing_exactly(*args, &block); end + + # Passes if actual covers expected. This works for + # Ranges. You can also pass in multiple args + # and it will only pass if all args are found in Range. + # + # ### Warning:: Ruby >= 1.9 only + # + # @example + # expect(1..10).to cover(5) + # expect(1..10).to cover(4, 6) + # expect(1..10).to cover(4, 6, 11) # fails + # expect(1..10).not_to cover(11) + # expect(1..10).not_to cover(5) # fails + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:528 + def cover(*values); end + + # Passes if actual covers expected. This works for + # Ranges. You can also pass in multiple args + # and it will only pass if all args are found in Range. + # + # ### Warning:: Ruby >= 1.9 only + # + # @example + # expect(1..10).to cover(5) + # expect(1..10).to cover(4, 6) + # expect(1..10).to cover(4, 6, 11) # fails + # expect(1..10).not_to cover(11) + # expect(1..10).not_to cover(5) # fails + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def covering(*args, &block); end + + # Matches if the actual value ends with the expected value(s). In the case + # of a string, matches against the last `expected.length` characters of the + # actual string. In the case of an array, matches against the last + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to end_with "string" + # expect([0, 1, 2, 3, 4]).to end_with 4 + # expect([0, 2, 3, 4, 4]).to end_with 3, 4 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:543 + def end_with(*expected); end + + # Matches if the actual value ends with the expected value(s). In the case + # of a string, matches against the last `expected.length` characters of the + # actual string. In the case of an array, matches against the last + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to end_with "string" + # expect([0, 1, 2, 3, 4]).to end_with 4 + # expect([0, 2, 3, 4, 4]).to end_with 3, 4 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def ending_with(*args, &block); end + + # Passes if <tt>actual == expected</tt>. + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eq(5) + # expect(5).not_to eq(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:558 + def eq(expected); end + + # Passes if <tt>actual == expected</tt>. + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eq(5) + # expect(5).not_to eq(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def eq_to(*args, &block); end + + # Passes if `actual.eql?(expected)` + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eql(5) + # expect(5).not_to eql(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:572 + def eql(expected); end + + # Passes if `actual.eql?(expected)` + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to eql(5) + # expect(5).not_to eql(3) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def eql_to(*args, &block); end + + # Passes if <tt>actual.equal?(expected)</tt> (object identity). + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to equal(5) # Integers are equal + # expect("5").not_to equal("5") # Strings that look the same are not the same object + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:586 + def equal(expected); end + + # Passes if <tt>actual.equal?(expected)</tt> (object identity). + # + # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more + # information about equality in Ruby. + # + # @example + # expect(5).to equal(5) # Integers are equal + # expect("5").not_to equal("5") # Strings that look the same are not the same object + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def equal_to(*args, &block); end + + # Passes if `actual.exist?` or `actual.exists?` + # + # @example + # expect(File).to exist("path/to/file") + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:596 + def exist(*args); end + + # Passes if `actual.exist?` or `actual.exists?` + # + # @example + # expect(File).to exist("path/to/file") + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def existing(*args, &block); end + + # Supports `expect(actual).to matcher` syntax by wrapping `actual` in an + # `ExpectationTarget`. + # + # @example + # expect(actual).to eq(expected) + # expect(actual).not_to eq(expected) + # @return [Expectations::ExpectationTarget] + # @see Expectations::ExpectationTarget#to + # @see Expectations::ExpectationTarget#not_to + # + # source://rspec-expectations-3.11.0/lib/rspec/expectations/syntax.rb:72 + def expect(value = T.unsafe(nil), &block); end + + # Passes if actual's attribute values match the expected attributes hash. + # This works no matter how you define your attribute readers. + # + # @example + # Person = Struct.new(:name, :age) + # person = Person.new("Bob", 32) + # + # expect(person).to have_attributes(:name => "Bob", :age => 32) + # expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) ) + # @example + # expect(person).to have_attributes(:color => "red") + # @note It will fail if actual doesn't respond to any of the expected attributes. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:616 + def have_attributes(expected); end + + # Passes if actual's attribute values match the expected attributes hash. + # This works no matter how you define your attribute readers. + # + # @example + # Person = Struct.new(:name, :age) + # person = Person.new("Bob", 32) + # + # expect(person).to have_attributes(:name => "Bob", :age => 32) + # expect(person).to have_attributes(:name => a_string_starting_with("B"), :age => (a_value > 30) ) + # @example + # expect(person).to have_attributes(:color => "red") + # @note It will fail if actual doesn't respond to any of the expected attributes. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def having_attributes(*args, &block); end + + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # @example + # expect([1,2,3]).to include(3) + # expect([1,2,3]).to include(2,3) + # expect([1,2,3]).to include(2,3,4) # fails + # expect([1,2,3]).not_to include(4) + # expect("spread").to include("read") + # expect("spread").not_to include("red") + # expect(:a => 1, :b => 2).to include(:a) + # expect(:a => 1, :b => 2).to include(:a, :b) + # expect(:a => 1, :b => 2).to include(:a => 1) + # expect(:a => 1, :b => 2).to include(:b => 2, :a => 1) + # expect(:a => 1, :b => 2).to include(:c) # fails + # expect(:a => 1, :b => 2).not_to include(:a => 2) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:639 + def include(*expected); end + + # Passes if actual includes expected. This works for + # collections and Strings. You can also pass in multiple args + # and it will only pass if all args are found in collection. + # + # @example + # expect([1,2,3]).to include(3) + # expect([1,2,3]).to include(2,3) + # expect([1,2,3]).to include(2,3,4) # fails + # expect([1,2,3]).not_to include(4) + # expect("spread").to include("read") + # expect("spread").not_to include("red") + # expect(:a => 1, :b => 2).to include(:a) + # expect(:a => 1, :b => 2).to include(:a, :b) + # expect(:a => 1, :b => 2).to include(:a => 1) + # expect(:a => 1, :b => 2).to include(:b => 2, :a => 1) + # expect(:a => 1, :b => 2).to include(:c) # fails + # expect(:a => 1, :b => 2).not_to include(:a => 2) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def including(*args, &block); end + + # Given a `Regexp` or `String`, passes if `actual.match(pattern)` + # Given an arbitrary nested data structure (e.g. arrays and hashes), + # matches if `expected === actual` || `actual == expected` for each + # pair of elements. + # + # @example + # expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # expect(email).to match("@example.com") + # @example + # hash = { + # :a => { + # :b => ["foo", 5], + # :c => { :d => 2.05 } + # } + # } + # + # expect(hash).to match( + # :a => { + # :b => a_collection_containing_exactly( + # a_string_starting_with("f"), + # an_instance_of(Integer) + # ), + # :c => { :d => (a_value < 3) } + # } + # ) + # @note The `match_regex` alias is deprecated and is not recommended for use. + # It was added in 2.12.1 to facilitate its use from within custom + # matchers (due to how the custom matcher DSL was evaluated in 2.x, + # `match` could not be used there), but is no longer needed in 3.x. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:697 + def match(expected); end + + # An alternate form of `contain_exactly` that accepts + # the expected contents as a single array arg rather + # that splatted out as individual items. + # + # @example + # expect(results).to contain_exactly(1, 2) + # # is identical to: + # expect(results).to match_array([1, 2]) + # @see #contain_exactly + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:715 + def match_array(items); end + + # Given a `Regexp` or `String`, passes if `actual.match(pattern)` + # Given an arbitrary nested data structure (e.g. arrays and hashes), + # matches if `expected === actual` || `actual == expected` for each + # pair of elements. + # + # @example + # expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # expect(email).to match("@example.com") + # @example + # hash = { + # :a => { + # :b => ["foo", 5], + # :c => { :d => 2.05 } + # } + # } + # + # expect(hash).to match( + # :a => { + # :b => a_collection_containing_exactly( + # a_string_starting_with("f"), + # an_instance_of(Integer) + # ), + # :c => { :d => (a_value < 3) } + # } + # ) + # @note The `match_regex` alias is deprecated and is not recommended for use. + # It was added in 2.12.1 to facilitate its use from within custom + # matchers (due to how the custom matcher DSL was evaluated in 2.x, + # `match` could not be used there), but is no longer needed in 3.x. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def match_regex(*args, &block); end + + # Given a `Regexp` or `String`, passes if `actual.match(pattern)` + # Given an arbitrary nested data structure (e.g. arrays and hashes), + # matches if `expected === actual` || `actual == expected` for each + # pair of elements. + # + # @example + # expect(email).to match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) + # expect(email).to match("@example.com") + # @example + # hash = { + # :a => { + # :b => ["foo", 5], + # :c => { :d => 2.05 } + # } + # } + # + # expect(hash).to match( + # :a => { + # :b => a_collection_containing_exactly( + # a_string_starting_with("f"), + # an_instance_of(Integer) + # ), + # :c => { :d => (a_value < 3) } + # } + # ) + # @note The `match_regex` alias is deprecated and is not recommended for use. + # It was added in 2.12.1 to facilitate its use from within custom + # matchers (due to how the custom matcher DSL was evaluated in 2.x, + # `match` could not be used there), but is no longer needed in 3.x. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def matching(*args, &block); end + + # With no arg, passes if the block outputs `to_stdout` or `to_stderr`. + # With a string, passes if the block outputs that specific string `to_stdout` or `to_stderr`. + # With a regexp or matcher, passes if the block outputs a string `to_stdout` or `to_stderr` that matches. + # + # To capture output from any spawned subprocess as well, use `to_stdout_from_any_process` or + # `to_stderr_from_any_process`. Output from any process that inherits the main process's corresponding + # standard stream will be captured. + # + # @example + # expect { print 'foo' }.to output.to_stdout + # expect { print 'foo' }.to output('foo').to_stdout + # expect { print 'foo' }.to output(/foo/).to_stdout + # + # expect { do_something }.to_not output.to_stdout + # + # expect { warn('foo') }.to output.to_stderr + # expect { warn('foo') }.to output('foo').to_stderr + # expect { warn('foo') }.to output(/foo/).to_stderr + # + # expect { do_something }.to_not output.to_stderr + # + # expect { system('echo foo') }.to output("foo\n").to_stdout_from_any_process + # expect { system('echo foo', out: :err) }.to output("foo\n").to_stderr_from_any_process + # @note `to_stdout` and `to_stderr` work by temporarily replacing `$stdout` or `$stderr`, + # so they're not able to intercept stream output that explicitly uses `STDOUT`/`STDERR` + # or that uses a reference to `$stdout`/`$stderr` that was stored before the + # matcher was used. + # @note `to_stdout_from_any_process` and `to_stderr_from_any_process` use Tempfiles, and + # are thus significantly (~30x) slower than `to_stdout` and `to_stderr`. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:749 + def output(expected = T.unsafe(nil)); end + + # With no args, matches if any error is raised. + # With a named error, matches only if that specific error is raised. + # With a named error and messsage specified as a String, matches only if both match. + # With a named error and messsage specified as a Regexp, matches only if both match. + # Pass an optional block to perform extra verifications on the exception matched + # + # @example + # expect { do_something_risky }.to raise_error + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky") + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/) + # expect { do_something_risky }.to raise_error("that was too risky") + # + # expect { do_something_risky }.not_to raise_error + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:770 + def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # With no args, matches if any error is raised. + # With a named error, matches only if that specific error is raised. + # With a named error and messsage specified as a String, matches only if both match. + # With a named error and messsage specified as a Regexp, matches only if both match. + # Pass an optional block to perform extra verifications on the exception matched + # + # @example + # expect { do_something_risky }.to raise_error + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky") + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/) + # expect { do_something_risky }.to raise_error("that was too risky") + # + # expect { do_something_risky }.not_to raise_error + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:770 + def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # With no args, matches if any error is raised. + # With a named error, matches only if that specific error is raised. + # With a named error and messsage specified as a String, matches only if both match. + # With a named error and messsage specified as a Regexp, matches only if both match. + # Pass an optional block to perform extra verifications on the exception matched + # + # @example + # expect { do_something_risky }.to raise_error + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError) { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error { |error| expect(error.data).to eq 42 } + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, "that was too risky") + # expect { do_something_risky }.to raise_error(PoorRiskDecisionError, /oo ri/) + # expect { do_something_risky }.to raise_error("that was too risky") + # + # expect { do_something_risky }.not_to raise_error + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def raising(*args, &block); end + + # Matches if the target object responds to all of the names + # provided. Names can be Strings or Symbols. + # + # @example + # expect("string").to respond_to(:length) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:789 + def respond_to(*names); end + + # Matches if the target object responds to all of the names + # provided. Names can be Strings or Symbols. + # + # @example + # expect("string").to respond_to(:length) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def responding_to(*args, &block); end + + # Passes if the submitted block returns true. Yields target to the + # block. + # + # Generally speaking, this should be thought of as a last resort when + # you can't find any other way to specify the behaviour you wish to + # specify. + # + # If you do find yourself in such a situation, you could always write + # a custom matcher, which would likely make your specs more expressive. + # + # @example + # expect(5).to satisfy { |n| n > 3 } + # expect(5).to satisfy("be greater than 3") { |n| n > 3 } + # @param description [String] optional description to be used for this matcher. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:810 + def satisfy(description = T.unsafe(nil), &block); end + + # Passes if the submitted block returns true. Yields target to the + # block. + # + # Generally speaking, this should be thought of as a last resort when + # you can't find any other way to specify the behaviour you wish to + # specify. + # + # If you do find yourself in such a situation, you could always write + # a custom matcher, which would likely make your specs more expressive. + # + # @example + # expect(5).to satisfy { |n| n > 3 } + # expect(5).to satisfy("be greater than 3") { |n| n > 3 } + # @param description [String] optional description to be used for this matcher. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def satisfying(*args, &block); end + + # Matches if the actual value starts with the expected value(s). In the + # case of a string, matches against the first `expected.length` characters + # of the actual string. In the case of an array, matches against the first + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to start_with "this s" + # expect([0, 1, 2, 3, 4]).to start_with 0 + # expect([0, 2, 3, 4, 4]).to start_with 0, 1 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:825 + def start_with(*expected); end + + # Matches if the actual value starts with the expected value(s). In the + # case of a string, matches against the first `expected.length` characters + # of the actual string. In the case of an array, matches against the first + # `expected.length` elements of the actual array. + # + # @example + # expect("this string").to start_with "this s" + # expect([0, 1, 2, 3, 4]).to start_with 0 + # expect([0, 2, 3, 4, 4]).to start_with 0, 1 + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def starting_with(*args, &block); end + + # Given no argument, matches if a proc throws any Symbol. + # + # Given a Symbol, matches if the given proc throws the specified Symbol. + # + # Given a Symbol and an arg, matches if the given proc throws the + # specified Symbol with the specified arg. + # + # @example + # expect { do_something_risky }.to throw_symbol + # expect { do_something_risky }.to throw_symbol(:that_was_risky) + # expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit') + # + # expect { do_something_risky }.not_to throw_symbol + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky) + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit') + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:847 + def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end + + # Given no argument, matches if a proc throws any Symbol. + # + # Given a Symbol, matches if the given proc throws the specified Symbol. + # + # Given a Symbol and an arg, matches if the given proc throws the + # specified Symbol with the specified arg. + # + # @example + # expect { do_something_risky }.to throw_symbol + # expect { do_something_risky }.to throw_symbol(:that_was_risky) + # expect { do_something_risky }.to throw_symbol(:that_was_risky, 'culprit') + # + # expect { do_something_risky }.not_to throw_symbol + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky) + # expect { do_something_risky }.not_to throw_symbol(:that_was_risky, 'culprit') + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def throwing(*args, &block); end + + # Passes if actual == expected +/- delta + # + # @example + # expect(result).to be_within(0.5).of(3.0) + # expect(result).not_to be_within(0.5).of(3.0) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def within(*args, &block); end + + # Passes if the method called in the expect block yields, regardless + # of whether or not arguments are yielded. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_control + # expect { |b| "a".to_sym(&b) }.not_to yield_control + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:868 + def yield_control; end + + # Designed for use with methods that repeatedly yield (such as + # iterators). Passes if the method called in the expect block yields + # multiple times with arguments matching those given. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3) + # expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2]) + # expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:937 + def yield_successive_args(*args); end + + # Given no arguments, matches if the method called in the expect + # block yields with arguments (regardless of what they are or how + # many there are). + # + # Given arguments, matches if the method called in the expect block + # yields with arguments that match the given arguments. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg + # expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5 + # expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5 + # expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt" + # + # expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args + # expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:916 + def yield_with_args(*args); end + + # Passes if the method called in the expect block yields with + # no arguments. Fails if it does not yield, or yields with arguments. + # + # @example + # expect { |b| User.transaction(&b) }.to yield_with_no_args + # expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5` + # expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:886 + def yield_with_no_args; end + + # Passes if the method called in the expect block yields, regardless + # of whether or not arguments are yielded. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_control + # expect { |b| "a".to_sym(&b) }.not_to yield_control + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def yielding_control(*args, &block); end + + # Designed for use with methods that repeatedly yield (such as + # iterators). Passes if the method called in the expect block yields + # multiple times with arguments matching those given. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3) + # expect { |b| { :a => 1, :b => 2 }.each(&b) }.to yield_successive_args([:a, 1], [:b, 2]) + # expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def yielding_successive_args(*args, &block); end + + # Given no arguments, matches if the method called in the expect + # block yields with arguments (regardless of what they are or how + # many there are). + # + # Given arguments, matches if the method called in the expect block + # yields with arguments that match the given arguments. + # + # Argument matching is done using `===` (the case match operator) + # and `==`. If the expected and actual arguments match with either + # operator, the matcher will pass. + # + # @example + # expect { |b| 5.tap(&b) }.to yield_with_args # because #tap yields an arg + # expect { |b| 5.tap(&b) }.to yield_with_args(5) # because 5 == 5 + # expect { |b| 5.tap(&b) }.to yield_with_args(Integer) # because Integer === 5 + # expect { |b| File.open("f.txt", &b) }.to yield_with_args(/txt/) # because /txt/ === "f.txt" + # + # expect { |b| User.transaction(&b) }.not_to yield_with_args # because it yields no args + # expect { |b| 5.tap(&b) }.not_to yield_with_args(1, 2, 3) + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def yielding_with_args(*args, &block); end + + # Passes if the method called in the expect block yields with + # no arguments. Fails if it does not yield, or yields with arguments. + # + # @example + # expect { |b| User.transaction(&b) }.to yield_with_no_args + # expect { |b| 5.tap(&b) }.not_to yield_with_no_args # because it yields with `5` + # expect { |b| "a".to_sym(&b) }.not_to yield_with_no_args # because it does not yield + # @note Your expect block must accept a parameter and pass it on to + # the method-under-test as a block. + # @note This matcher is not designed for use with methods that yield + # multiple times. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:38 + def yielding_with_no_args(*args, &block); end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:958 + def method_missing(method, *args, &block); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:971 + def respond_to_missing?(method, *_arg1); end + + class << self + # Extended from {RSpec::Matchers::DSL#alias_matcher}. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:250 + def alias_matcher(*args, &block); end + + # Used by rspec-core to clear the state used to generate + # descriptions after an example. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:11 + def clear_generated_description; end + + # Delegates to {RSpec::Expectations.configuration}. + # This is here because rspec-core's `expect_with` option + # looks for a `configuration` method on the mixin + # (`RSpec::Matchers`) to yield to a block. + # + # @return [RSpec::Expectations::Configuration] the configuration object + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:948 + def configuration; end + + # Generates an an example description based on the last expectation. + # Used by rspec-core's one-liner syntax. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:19 + def generated_description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:1005 + def is_a_describable_matcher?(obj); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:985 + def is_a_matcher?(obj); end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:25 + def last_description; end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:5 + def last_expectation_handler; end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:5 + def last_expectation_handler=(_arg0); end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:5 + def last_matcher; end + + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/generated_descriptions.rb:5 + def last_matcher=(_arg0); end + end +end + +# Decorator that wraps a matcher and overrides `description` +# using the provided block in order to support an alias +# of a matcher. This is intended for use when composing +# matchers, so that you can use an expression like +# `include( a_value_within(0.1).of(3) )` rather than +# `include( be_within(0.1).of(3) )`, and have the corresponding +# description read naturally. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:12 +class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator + # @api private + # @return [AliasedMatcher] a new instance of AliasedMatcher + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:13 + def initialize(base_matcher, description_block); end + + # Provides the description of the aliased matcher. Aliased matchers + # are designed to behave identically to the original matcher except + # for the description and failure messages. The description is different + # to reflect the aliased name. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:36 + def description; end + + # Provides the failure_message of the aliased matcher. Aliased matchers + # are designed to behave identically to the original matcher except + # for the description and failure messages. The failure_message is different + # to reflect the aliased name. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:46 + def failure_message; end + + # Provides the failure_message_when_negated of the aliased matcher. Aliased matchers + # are designed to behave identically to the original matcher except + # for the description and failure messages. The failure_message_when_negated is different + # to reflect the aliased name. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:56 + def failure_message_when_negated; end + + # Forward messages on to the wrapped matcher. + # Since many matchers provide a fluent interface + # (e.g. `a_value_within(0.1).of(3)`), we need to wrap + # the returned value if it responds to `description`, + # so that our override can be applied when it is eventually + # used. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:24 + def method_missing(*_arg0); end +end + +# Decorator used for matchers that have special implementations of +# operators like `==` and `===`. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:65 +class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:71 +class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:80 + def does_not_match?(*args, &block); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:84 + def failure_message; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:88 + def failure_message_when_negated; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:72 + def matches?(*args, &block); end + + private + + # For a matcher that uses the default failure messages, we prefer to + # use the override provided by the `description_block`, because it + # includes the phrasing that the user has expressed a preference for + # by going through the effort of defining a negated matcher. + # + # However, if the override didn't actually change anything, then we + # should return the opposite failure message instead -- the overriden + # message is going to be confusing if we return it as-is, as it represents + # the non-negated failure message for a negated match (or vice versa). + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:105 + def optimal_failure_message(same, inverted); end +end + +# source://rspec-expectations-3.11.0/lib/rspec/matchers/aliased_matcher.rb:94 +RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + +# source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:954 +RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp) + +# Container module for all built-in matchers. The matcher classes are here +# (rather than directly under `RSpec::Matchers`) in order to prevent name +# collisions, since `RSpec::Matchers` gets included into the user's namespace. +# +# Autoloading is used to delay when the matcher classes get loaded, allowing +# rspec-matchers to boot faster, and avoiding loading matchers the user is +# not using. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:3 +module RSpec::Matchers::BuiltIn; end + +# Provides the implementation for `all`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:8 +class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [All] a new instance of All + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:11 + def initialize(matcher); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:37 + def description; end + + # @api private + # @private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:17 + def does_not_match?(_actual); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:9 + def failed_objects; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:23 + def failure_message; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:9 + def matcher; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:63 + def add_new_line_if_needed(message); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:58 + def failure_message_for_item(index, failure_message); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:67 + def indent_multiline_message(message); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:50 + def index_failed_objects; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:74 + def initialize_copy(other); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:80 + def iterable?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/all.rb:43 + def match(_expected, _actual); end +end + +# Used _internally_ as a base class for matchers that ship with +# rspec-expectations and rspec-rails. +# +# ### Warning: +# +# This class is for internal use, and subject to change without notice. +# We strongly recommend that you do not base your custom matchers on this +# class. If/when this changes, we will announce it and remove this warning. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:14 +class RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::Composable + include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + + # @api private + # @return [BaseMatcher] a new instance of BaseMatcher + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:28 + def initialize(expected = T.unsafe(nil)); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:23 + def actual; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:97 + def actual_formatted; end + + # Generates a description using {EnglishPhrasing}. + # + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:60 + def description; end + + # Matchers are not diffable by default. Override this to make your + # subclass diffable. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:69 + def diffable?; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:23 + def expected; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:92 + def expected_formatted; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:87 + def expects_call_stack_jump?; end + + # Used to wrap a block of code that will indicate failure by + # raising one of the named exceptions. + # + # This is used by rspec-rails for some of its matchers that + # wrap rails' assertions. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:47 + def match_unless_raises(*exceptions); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:107 + def matcher_name; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:26 + def matcher_name=(_arg0); end + + # Indicates if the match is successful. Delegates to `match`, which + # should be defined on a subclass. Takes care of consistently + # initializing the `actual` attribute. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:36 + def matches?(actual); end + + # :nocov: + # + # @api private + def present_ivars; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:23 + def rescued_exception; end + + # Most matchers are value matchers (i.e. meant to work with `expect(value)`) + # rather than block matchers (i.e. meant to work with `expect { }`), so + # this defaults to false. Block matchers must override this to return true. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:77 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:82 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:129 + def assert_ivars(*expected_ivars); end + + class << self + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:102 + def matcher_name; end + + private + + # Borrowed from ActiveSupport. + # + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:117 + def underscore(camel_cased_word); end + end +end + +# Provides default implementations of failure messages, based on the `description`. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:166 +module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + # Provides a good generic failure message. Based on `description`. + # When subclassing, if you are not satisfied with this failure message + # you often only need to override `description`. + # + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:172 + def failure_message; end + + # Provides a good generic negative failure message. Based on `description`. + # When subclassing, if you are not satisfied with this failure message + # you often only need to override `description`. + # + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:181 + def failure_message_when_negated; end + + class << self + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:186 + def has_default_failure_messages?(matcher); end + end +end + +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:146 +module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + private + + # `{ :a => 5, :b => 2 }.inspect` produces: + # + # {:a=>5, :b=>2} + # + # ...but it looks much better as: + # + # {:a => 5, :b => 2} + # + # This is idempotent and safe to run on a string multiple times. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:156 + def improve_hash_formatting(inspect_string); end + + class << self + # `{ :a => 5, :b => 2 }.inspect` produces: + # + # {:a=>5, :b=>2} + # + # ...but it looks much better as: + # + # {:a => 5, :b => 2} + # + # This is idempotent and safe to run on a string multiple times. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:156 + def improve_hash_formatting(inspect_string); end + end +end + +# Used to detect when no arg is passed to `initialize`. +# `nil` cannot be used because it's a valid value to pass. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb:20 +RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object) + +# Provides the implementation for `be`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:101 +class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::BuiltIn::BeHelpers + + # @api private + # @return [Be] a new instance of Be + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:104 + def initialize(*args); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def <(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def <=(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def ==(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def ===(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def =~(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def >(operand); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:121 + def >=(operand); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:110 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:116 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:128 + def match(_, actual); end +end + +# Provides the implementation for `be_a_kind_of`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_kind_of.rb:7 +class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_kind_of.rb:10 + def match(expected, actual); end +end + +# Provides the implementation for `be_an_instance_of`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_instance_of.rb:9 +class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_instance_of.rb:10 + def description; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_instance_of.rb:16 + def match(expected, actual); end +end + +# Provides the implementation for `be_between`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:7 +class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [BeBetween] a new instance of BeBetween + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:8 + def initialize(min, max); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:57 + def description; end + + # Makes the between comparison exclusive. + # + # @api public + # @example + # expect(3).to be_between(2, 4).exclusive + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:33 + def exclusive; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:51 + def failure_message; end + + # Makes the between comparison inclusive. + # + # @api public + # @example + # expect(3).to be_between(2, 3).inclusive + # @note The matcher is inclusive by default; this simply provides + # a way to be more explicit about it. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:21 + def inclusive; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:42 + def matches?(actual); end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:63 + def comparable?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:71 + def compare; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_between.rb:67 + def not_comparable_clause; end +end + +# Provides the implementation of `be <operator> value`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:136 +class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::BuiltIn::BeHelpers + + # @api private + # @return [BeComparedTo] a new instance of BeComparedTo + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:139 + def initialize(operand, operator); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:178 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:151 + def does_not_match?(actual); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:159 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:166 + def failure_message_when_negated; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:145 + def matches?(actual); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:184 + def perform_match(actual); end +end + +# Provides the implementation for `be_falsey`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:32 +class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:33 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:39 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:45 + def match(_, actual); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:74 +module RSpec::Matchers::BuiltIn::BeHelpers + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:77 + def args_to_s; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:93 + def args_to_sentence; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:89 + def expected_to_sentence; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:85 + def inspected_args; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:81 + def parenthesize(string); end +end + +# Provides the implementation for `be_nil`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:55 +class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:56 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:62 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:68 + def match(_, actual); end +end + +# Provides the implementation of `be_<predicate>`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:138 +class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:149 + def failure_to_respond_explanation; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:141 + def predicate; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:157 + def predicate_accessible?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:145 + def predicate_method_name; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:161 + def present_tense_predicate; end +end + +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:139 +RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp) + +# Provides the implementation for `be_truthy`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:9 +class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:10 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:16 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be.rb:22 + def match(_, actual); end +end + +# Provides the implementation for `be_within`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:7 +class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [BeWithin] a new instance of BeWithin + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:8 + def initialize(delta); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:52 + def description; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:40 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:46 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:32 + def matches?(actual); end + + # Sets the expected value. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:14 + def of(expected); end + + # Sets the expected value, and makes the matcher do + # a percent comparison. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:24 + def percent_of(expected); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:62 + def needs_expected; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:66 + def not_numeric_clause; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/be_within.rb:58 + def numeric?; end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:159 +module RSpec::Matchers::BuiltIn::CaptureStderr + class << self + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:164 + def capture(block); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:160 + def name; end + end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:139 +module RSpec::Matchers::BuiltIn::CaptureStdout + class << self + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:144 + def capture(block); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:140 + def name; end + end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:179 +class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:180 + def capture(block); end +end + +# Provides the implementation for `change`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:9 +class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Change] a new instance of Change + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:87 + def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # Specifies the delta of the expected change. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:10 + def by(expected_delta); end + + # Specifies a minimum delta of the expected change. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:18 + def by_at_least(minimum); end + + # Specifies a maximum delta of the expected change. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:26 + def by_at_most(maximum); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:71 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:50 + def does_not_match?(event_proc); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:57 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:64 + def failure_message_when_negated; end + + # Specifies the original value. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:40 + def from(value); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:45 + def matches?(event_proc); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:76 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:81 + def supports_value_expectations?; end + + # Specifies the new value you expect. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:34 + def to(value); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:93 + def change_details; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:119 + def negative_failure_reason; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:97 + def perform_change(event_proc); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:114 + def positive_failure_reason; end + + # @api private + # @raise [SyntaxError] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:109 + def raise_block_syntax_error; end +end + +# Encapsulates the details of the before/after values. +# +# Note that this class exposes the `actual_after` value, to allow the +# matchers above to derive failure messages, etc from the value on demand +# as needed, but it intentionally does _not_ expose the `actual_before` +# value. Some usages of the `change` matcher mutate a specific object +# returned by the value proc, which means that failure message snippets, +# etc, which are derived from the `before` value may not be accurate if +# they are lazily computed as needed. We must pre-compute them before +# applying the change in the `expect` block. To ensure that all `change` +# matchers do that properly, we do not expose the `actual_before` value. +# Instead, matchers must pass a block to `perform_change`, which yields +# the `actual_before` value before applying the change. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:352 +class RSpec::Matchers::BuiltIn::ChangeDetails + # @return [ChangeDetails] a new instance of ChangeDetails + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:357 + def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end + + # Returns the value of attribute actual_after. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:353 + def actual_after; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:418 + def actual_delta; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:402 + def changed?; end + + # @yield [@actual_before] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:389 + def perform_change(event_proc); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:378 + def value_representation; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:424 + def evaluate_value_proc; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:438 + def extract_value_block_snippet; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:428 + def message_notation(receiver, message); end +end + +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:355 +module RSpec::Matchers::BuiltIn::ChangeDetails::UNDEFINED; end + +# Used to specify a change from a specific value +# (and, optionally, to a specific value). +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:270 +class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange + # @api private + # @return [ChangeFromValue] a new instance of ChangeFromValue + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:271 + def initialize(change_details, expected_before); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:285 + def does_not_match?(event_proc); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:295 + def failure_message_when_negated; end + + # Specifies the new value you expect. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:278 + def to(value); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:303 + def change_description; end +end + +# Used to specify a relative change. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:128 +class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [ChangeRelatively] a new instance of ChangeRelatively + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:129 + def initialize(change_details, expected_delta, relativity, &comparer); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:156 + def description; end + + # @api private + # @private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:150 + def does_not_match?(_event_proc); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:137 + def failure_message; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:144 + def matches?(event_proc); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:162 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:167 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:173 + def failure_reason; end +end + +# Used to specify a change to a specific value +# (and, optionally, from a specific value). +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:311 +class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange + # @api private + # @return [ChangeToValue] a new instance of ChangeToValue + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:312 + def initialize(change_details, expected_after); end + + # @api private + # @private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:326 + def does_not_match?(_event_proc); end + + # Specifies the original value. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:319 + def from(value); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:333 + def change_description; end +end + +# Base class for `and` and `or` compound matchers. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:7 +class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Compound] a new instance of Compound + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:10 + def initialize(matcher_1, matcher_2); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:25 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:49 + def diffable?; end + + # @api private + # @private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:16 + def does_not_match?(_actual); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:8 + def evaluator; end + + # @api private + # @return [RSpec::Matchers::ExpectedsForMultipleDiffs] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:55 + def expected; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:42 + def expects_call_stack_jump?; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:8 + def matcher_1; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:8 + def matcher_2; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:30 + def supports_block_expectations?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:36 + def supports_value_expectations?; end + + protected + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:62 + def diffable_matcher_list; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:93 + def compound_failure_message; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:125 + def diffable_matcher_list_for(matcher); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:87 + def indent_multiline_message(message); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:71 + def initialize_copy(other); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:77 + def match(_expected, actual); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:99 + def matcher_1_matches?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:103 + def matcher_2_matches?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:119 + def matcher_is_diffable?(matcher); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:107 + def matcher_supports_block_expectations?(matcher); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:113 + def matcher_supports_value_expectations?(matcher); end +end + +# Matcher used to represent a compound `and` expectation. +# +# @api public +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:244 +class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:245 + def failure_message; end + + private + + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:262 + def conjunction; end + + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:257 + def match(*_arg0); end +end + +# Normally, we evaluate the matching sequentially. For an expression like +# `expect(x).to foo.and bar`, this becomes: +# +# expect(x).to foo +# expect(x).to bar +# +# For block expectations, we need to nest them instead, so that +# `expect { x }.to foo.and bar` becomes: +# +# expect { +# expect { x }.to foo +# }.to bar +# +# This is necessary so that the `expect` block is only executed once. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:156 +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + # @api private + # @return [NestedEvaluator] a new instance of NestedEvaluator + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:157 + def initialize(actual, matcher_1, matcher_2); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:170 + def matcher_matches?(matcher); end + + private + + # Some block matchers (such as `yield_xyz`) pass args to the `expect` block. + # When such a matcher is used as the outer matcher, we need to forward the + # the args on to the `expect` block. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:184 + def inner_matcher_block(outer_args); end + + # For a matcher like `raise_error` or `throw_symbol`, where the block will jump + # up the call stack, we need to order things so that it is the inner matcher. + # For example, we need it to be this: + # + # expect { + # expect { + # x += 1 + # raise "boom" + # }.to raise_error("boom") + # }.to change { x }.by(1) + # + # ...rather than: + # + # expect { + # expect { + # x += 1 + # raise "boom" + # }.to change { x }.by(1) + # }.to raise_error("boom") + # + # In the latter case, the after-block logic in the `change` matcher would never + # get executed because the `raise "boom"` line would jump to the `rescue` in the + # `raise_error` logic, so only the former case will work properly. + # + # This method figures out which matcher should be the inner matcher and which + # should be the outer matcher. + # + # @api private + # @raise [ArgumentError] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:224 + def order_block_matchers; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:233 + def matcher_expects_call_stack_jump?(matcher); end + end +end + +# Matcher used to represent a compound `or` expectation. +# +# @api public +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:271 +class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:272 + def failure_message; end + + private + + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:283 + def conjunction; end + + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:278 + def match(*_arg0); end +end + +# For value expectations, we can evaluate the matchers sequentially. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:132 +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator + # @api private + # @return [SequentialEvaluator] a new instance of SequentialEvaluator + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:133 + def initialize(actual, *_arg1); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/compound.rb:137 + def matcher_matches?(matcher); end +end + +# Provides the implementation for `contain_exactly` and `match_array`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:10 +class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:29 + def description; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:11 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:22 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:48 + def actual_collection_line; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:127 + def best_solution; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:86 + def convert_actual_to_an_array; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:60 + def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:44 + def expected_collection_line; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:56 + def extra_elements_line; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:121 + def extra_items; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:36 + def generate_failure_message; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:73 + def match(_expected, _actual); end + + # This cannot always work (e.g. when dealing with unsortable items, + # or matchers as expected items), but it's practically free compared to + # the slowness of the full matching algorithm, and in common cases this + # works, so it's worth a try. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:82 + def match_when_sorted?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:68 + def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:52 + def missing_elements_line; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:115 + def missing_items; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:131 + def pairings_maximizer; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:96 + def safe_sort(array); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:110 + def to_a_disallowed?(object); end +end + +# Once we started supporting composing matchers, the algorithm for this matcher got +# much more complicated. Consider this expression: +# +# expect(["fool", "food"]).to contain_exactly(/foo/, /fool/) +# +# This should pass (because we can pair /fool/ with "fool" and /foo/ with "food"), but +# the original algorithm used by this matcher would pair the first elements it could +# (/foo/ with "fool"), which would leave /fool/ and "food" unmatched. When we have +# an expected element which is a matcher that matches a superset of actual items +# compared to another expected element matcher, we need to consider every possible pairing. +# +# This class is designed to maximize the number of actual/expected pairings -- or, +# conversely, to minimize the number of unpaired items. It's essentially a brute +# force solution, but with a few heuristics applied to reduce the size of the +# problem space: +# +# * Any items which match none of the items in the other list are immediately +# placed into the `unmatched_expected_indexes` or `unmatched_actual_indexes` array. +# The extra items and missing items in the matcher failure message are derived +# from these arrays. +# * Any items which reciprocally match only each other are paired up and not +# considered further. +# +# What's left is only the items which match multiple items from the other list +# (or vice versa). From here, it performs a brute-force depth-first search, +# looking for a solution which pairs all elements in both lists, or, barring that, +# that produces the fewest unmatched items. +# +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:178 +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer + # @api private + # @return [PairingsMaximizer] a new instance of PairingsMaximizer + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:215 + def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:213 + def actual_to_expected_matched_indexes; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:213 + def expected_to_actual_matched_indexes; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:229 + def find_best_solution; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:213 + def solution; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:291 + def apply_pairing_to(indeterminates, original_matches, other_list_index); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:275 + def best_solution_for_pairing(expected_index, actual_index); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:255 + def categorize_indexes(indexes_to_categorize, other_indexes); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:270 + def reciprocal_single_match?(matches, index, other_list); end +end + +# Starting solution that is worse than any other real solution. +# +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:249 +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution + class << self + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:250 + def worse_than?(_other); end + end +end + +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:180 +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:202 + def +(derived_candidate_solution); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:186 + def candidate?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:191 + def ideal?; end + + # Returns the value of attribute indeterminate_actual_indexes + # + # @return [Object] the current value of indeterminate_actual_indexes + def indeterminate_actual_indexes; end + + # Sets the attribute indeterminate_actual_indexes + # + # @param value [Object] the value to set the attribute indeterminate_actual_indexes to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:180 + def indeterminate_actual_indexes=(_); end + + # Returns the value of attribute indeterminate_expected_indexes + # + # @return [Object] the current value of indeterminate_expected_indexes + def indeterminate_expected_indexes; end + + # Sets the attribute indeterminate_expected_indexes + # + # @param value [Object] the value to set the attribute indeterminate_expected_indexes to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:180 + def indeterminate_expected_indexes=(_); end + + # Returns the value of attribute unmatched_actual_indexes + # + # @return [Object] the current value of unmatched_actual_indexes + def unmatched_actual_indexes; end + + # Sets the attribute unmatched_actual_indexes + # + # @param value [Object] the value to set the attribute unmatched_actual_indexes to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:180 + def unmatched_actual_indexes=(_); end + + # Returns the value of attribute unmatched_expected_indexes + # + # @return [Object] the current value of unmatched_expected_indexes + def unmatched_expected_indexes; end + + # Sets the attribute unmatched_expected_indexes + # + # @param value [Object] the value to set the attribute unmatched_expected_indexes to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:180 + def unmatched_expected_indexes=(_); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:198 + def unmatched_item_count; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/contain_exactly.rb:182 + def worse_than?(other); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Asbtract class to implement `once`, `at_least` and other +# count constraints. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:7 +module RSpec::Matchers::BuiltIn::CountExpectation + # Specifies the minimum number of times the method is expected to match + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:42 + def at_least(number); end + + # Specifies the maximum number of times the method is expected to match + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:35 + def at_most(number); end + + # Specifies that the method is expected to match the given number of times. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:28 + def exactly(number); end + + # Specifies that the method is expected to match once. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:10 + def once; end + + # Specifies that the method is expected to match thrice. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:22 + def thrice; end + + # No-op. Provides syntactic sugar. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:49 + def times; end + + # Specifies that the method is expected to match twice. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:16 + def twice; end + + protected + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:55 + def count_expectation_type; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:55 + def expected_count; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:120 + def count_constraint_to_number(n); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:139 + def count_expectation_description; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:143 + def count_failure_reason(action); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:60 + def cover?(count, number); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:69 + def expected_count_matches?(actual_count); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:77 + def has_expected_count?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:157 + def human_readable_count(count); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:148 + def human_readable_expectation_type; end + + # @api private + # @raise [ArgumentError] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:100 + def raise_impossible_count_expectation(count); end + + # @api private + # @raise [ArgumentError] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:109 + def raise_unsupported_count_expectation; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:81 + def set_expected_count(relativity, n); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/count_expectation.rb:132 + def unsupported_count_expectation?(relativity); end +end + +# Provides the implementation for `cover`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/cover.rb:7 +class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Cover] a new instance of Cover + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/cover.rb:8 + def initialize(*expected); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/cover.rb:17 + def does_not_match?(range); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/cover.rb:12 + def matches?(range); end +end + +# Provides the implementation for dynamic predicate matchers. +# Not intended to be inherited directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:7 +class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::BuiltIn::BeHelpers + + # @api private + # @return [DynamicPredicate] a new instance of DynamicPredicate + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:10 + def initialize(method_name, *args, &block); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:43 + def description; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:23 + def does_not_match?(actual, &block); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:31 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:37 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:16 + def matches?(actual, &block); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:99 + def expectation_of(value); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:94 + def failure_message_expecting(value); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:115 + def failure_to_respond_explanation; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:90 + def method_description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:49 + def predicate_accessible?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:74 + def predicate_matches?(value = T.unsafe(nil)); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:70 + def predicate_method_name; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:66 + def predicate_result; end + + # :nocov: + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:61 + def private_predicate?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:82 + def root; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:109 + def validity_message; end +end + +# Provides the implementation for `end_with`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:81 +class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:88 + def element_matches?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:84 + def subset_matches?; end +end + +# Provides the implementation for `eq`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:9 +class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:22 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:28 + def diffable?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:10 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:16 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eq.rb:34 + def match(expected, actual); end +end + +# Provides the implementation for `eql`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eql.rb:9 +class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eql.rb:22 + def diffable?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eql.rb:10 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eql.rb:16 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/eql.rb:28 + def match(expected, actual); end +end + +# Provides the implementation for `equal`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:9 +class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:33 + def diffable?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:10 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:20 + def failure_message_when_negated; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:49 + def actual_inspected; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:61 + def detailed_failure_message; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:45 + def expected_is_a_literal_singleton?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:75 + def inspect_object(o); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:39 + def match(expected, actual); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:57 + def simple_failure_message; end +end + +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/equal.rb:43 +RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array) + +# Provides the implementation for `exist`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:7 +class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Exist] a new instance of Exist + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:8 + def initialize(*expected); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:22 + def does_not_match?(actual); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:30 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:36 + def failure_message_when_negated; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:14 + def matches?(actual); end +end + +# Simple class for memoizing actual/expected for this matcher +# and examining the match +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:45 +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:52 + def actual_exists?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:46 + def valid_test?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:58 + def validity_message; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:83 + def deprecated(predicate, actual); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:75 + def existence_values; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:79 + def predicates; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/exist.rb:71 + def uniq_truthy_values; end +end + +# Provides the implementation for `has_<predicate>`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:126 +class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:129 + def predicate; end +end + +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/has.rb:127 +RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp) + +# Provides the implementation for `have_attributes`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:8 +class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [HaveAttributes] a new instance of HaveAttributes + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:11 + def initialize(expected); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:19 + def actual; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:43 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:50 + def diffable?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:34 + def does_not_match?(actual); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:56 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:64 + def failure_message_when_negated; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:25 + def matches?(actual); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:9 + def respond_to_failed; end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:85 + def actual_has_attribute?(attribute_key, attribute_value); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:70 + def cache_all_values; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:107 + def formatted_values; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:78 + def perform_match(predicate); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:89 + def respond_to_attributes?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:99 + def respond_to_failure_message_or; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/have_attributes.rb:95 + def respond_to_matcher; end +end + +# Provides the implementation for `include`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:9 +class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::BuiltIn::CountExpectation + + # @api private + # @return [Include] a new instance of Include + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:15 + def initialize(*expecteds); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:43 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:61 + def diffable?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:32 + def does_not_match?(actual); end + + # @api private + # @return [Array, Hash] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:67 + def expected; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:12 + def expecteds; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:49 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:55 + def failure_message_when_negated; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:21 + def matches?(actual); end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:160 + def actual_collection_includes?(expected_item); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:153 + def actual_hash_has_key?(expected_key); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:141 + def actual_hash_includes?(expected_key, expected_value); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:77 + def check_actual?(actual); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:83 + def check_expected_count?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:149 + def comparing_hash_keys?(expected_item); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:137 + def comparing_hash_to_a_subset?(expected_item); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:200 + def convert_to_hash?(obj); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:174 + def count_enumerable(expected_item); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:179 + def count_inclusions; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:191 + def diff_would_wrongly_highlight_matched_item?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:120 + def excluded_from_actual; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:95 + def format_failure_message(preposition); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:115 + def perform_match(&block); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/include.rb:106 + def readable_list_of(items); end +end + +# Provides the implementation for `match`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:7 +class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Match] a new instance of Match + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:8 + def initialize(expected); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:15 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:25 + def diffable?; end + + # Used to specify the captures we match against + # + # @api private + # @return [self] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:31 + def with_captures(*captures); end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:45 + def can_safely_call_match?(expected, actual); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:38 + def match(expected, actual); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:52 + def match_captures(expected, actual); end +end + +# Handles operator matcher for `should_not`. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:116 +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:117 + def __delegate_operator(actual, operator, expected); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:128 +module RSpec::Matchers::BuiltIn::NullCapture + class << self + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:133 + def capture(_block); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:129 + def name; end + end +end + +# Provides the implementation for operator matchers. +# Not intended to be instantiated directly. +# Only available for use with `should`. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:10 +class RSpec::Matchers::BuiltIn::OperatorMatcher + # @api private + # @return [OperatorMatcher] a new instance of OperatorMatcher + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:41 + def initialize(actual); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:57 + def !=(_expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:57 + def !~(_expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def <(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def <=(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def ==(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def ===(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def =~(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def >(expected); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:47 + def >=(expected); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:76 + def description; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:70 + def fail_with_message(message); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:88 + def eval_match(actual, operator, expected); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:82 + def has_non_generic_implementation_of?(op); end + + class << self + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:29 + def get(klass, operator); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:18 + def register(klass, operator, matcher); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:13 + def registry; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:24 + def unregister(klass, operator); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:46 + def use_custom_matcher_or_delegate(operator); end + end +end + +# Provides the implementation for `output`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:9 +class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Output] a new instance of Output + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:10 + def initialize(expected); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:76 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:86 + def diffable?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:24 + def does_not_match?(block); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:64 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:70 + def failure_message_when_negated; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:17 + def matches?(block); end + + # Indicates this matcher matches against a block. + # + # @api private + # @return [True] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:93 + def supports_block_expectations?; end + + # Indicates this matcher matches against a block only. + # + # @api private + # @return [False] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:100 + def supports_value_expectations?; end + + # Tells the matcher to match against stderr. + # Works only when the main Ruby process prints to stderr + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:39 + def to_stderr; end + + # Tells the matcher to match against stderr. + # Works when subprocesses print to stderr as well. + # This is significantly (~30x) slower than `to_stderr` + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:57 + def to_stderr_from_any_process; end + + # Tells the matcher to match against stdout. + # Works only when the main Ruby process prints to stdout + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:31 + def to_stdout; end + + # Tells the matcher to match against stdout. + # Works when subprocesses print to stdout as well. + # This is significantly (~30x) slower than `to_stdout` + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:48 + def to_stdout_from_any_process; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:121 + def actual_output_description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:106 + def captured?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:116 + def negative_failure_reason; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/output.rb:110 + def positive_failure_reason; end +end + +# Handles operator matcher for `should`. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:97 +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/operators.rb:98 + def __delegate_operator(actual, operator, expected); end +end + +# Provides the implementation for `raise_error`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:9 +class RSpec::Matchers::BuiltIn::RaiseError + include ::RSpec::Matchers::Composable + + # @api private + # @return [RaiseError] a new instance of RaiseError + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:18 + def initialize(expected_error_or_message, expected_message, &block); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:113 + def description; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:79 + def does_not_match?(given_proc); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:95 + def expects_call_stack_jump?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:101 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:107 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:48 + def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:85 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:90 + def supports_value_expectations?; end + + # Specifies the expected error message. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:39 + def with_message(expected_message); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:119 + def actual_error_message; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:133 + def block_matches?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:129 + def error_and_message_match?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:141 + def eval_block; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:125 + def expectation_matched?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:222 + def expected_error; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:253 + def expecting_specific_exception?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:237 + def format_backtrace(backtrace); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:242 + def given_error; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:172 + def handle_warning(message); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:257 + def raise_message_already_set; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:137 + def ready_to_eval_block?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:151 + def verify_message; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:184 + def warn_about_bare_error!; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:176 + def warn_about_bare_error?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:210 + def warn_about_negative_false_positive!(expression); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:197 + def warn_about_nil_error!; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:180 + def warn_about_nil_error?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:156 + def warn_for_negative_false_positives!; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:262 + def warning; end +end + +# Used as a sentinel value to be able to tell when the user did not pass an +# argument. We can't use `nil` for that because we need to warn when `nil` is +# passed in a different way. It's an Object, not a Module, since Module's `===` +# does not evaluate to true when compared to itself. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/raise_error.rb:16 +RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object) + +# Used to wrap match data and make it reliable for 1.8.7 +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:72 +class RSpec::Matchers::BuiltIn::ReliableMatchData + # @api private + # @return [ReliableMatchData] a new instance of ReliableMatchData + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:73 + def initialize(match_data); end + + # returns an array of captures from the match data + # + # @api private + # @return Array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:96 + def captures; end + + # Returns match data names for named captures + # + # @api private + # @return Array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:88 + def names; end + + protected + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/match.rb:102 + def match_data; end +end + +# Provides the implementation for `respond_to`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:9 +class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [RespondTo] a new instance of RespondTo + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:10 + def initialize(*names); end + + # Specifies that the method accepts any keyword, i.e. the method has + # a splatted keyword parameter of the form **kw_args. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_any_keywords + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:48 + def and_any_keywords; end + + # Specifies keyword arguments, if any. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_keywords(:color, :shape) + # @example with an expected number of arguments + # expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:36 + def and_keywords(*keywords); end + + # Specifies that the number of arguments has no upper limit, i.e. the + # method has a splatted parameter of the form *args. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_unlimited_arguments + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:60 + def and_unlimited_arguments; end + + # No-op. Intended to be used as syntactic sugar when using `with`. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with(3).arguments + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:71 + def argument; end + + # No-op. Intended to be used as syntactic sugar when using `with`. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with(3).arguments + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:71 + def arguments; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:100 + def description; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:82 + def does_not_match?(actual); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:88 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:94 + def failure_message_when_negated; end + + # Used by other matchers to suppress a check + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:106 + def ignoring_method_signature_failure!; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:77 + def matches?(actual); end + + # Specifies the number of expected arguments. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with(3).arguments + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:24 + def with(n); end + + # Specifies that the method accepts any keyword, i.e. the method has + # a splatted keyword parameter of the form **kw_args. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_any_keywords + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:48 + def with_any_keywords; end + + # Specifies keyword arguments, if any. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_keywords(:color, :shape) + # @example with an expected number of arguments + # expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:36 + def with_keywords(*keywords); end + + # Specifies that the number of arguments has no upper limit, i.e. the + # method has a splatted parameter of the form *args. + # + # @api public + # @example + # expect(obj).to respond_to(:message).with_unlimited_arguments + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:60 + def with_unlimited_arguments; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:112 + def find_failing_method_names(actual, filter_method); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:119 + def matches_arity?(actual, name); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:156 + def pp_names; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:130 + def with_arity; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:139 + def with_arity_string; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:143 + def with_keywords_string; end +end + +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:161 +class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck + # @api private + # @return [ArityCheck] a new instance of ArityCheck + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:162 + def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:178 + def matches?(actual, name); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:187 + def method_signature_for(actual, name); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/respond_to.rb:183 + def verifier_for(actual, name); end +end + +# Provides the implementation for `satisfy`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:7 +class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [Satisfy] a new instance of Satisfy + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:8 + def initialize(description = T.unsafe(nil), &block); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:21 + def description; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:27 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:33 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:14 + def matches?(actual, &block); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:40 + def block_representation; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/satisfy.rb:48 + def extract_block_snippet; end +end + +# Base class for specifying a change from and/or to specific values. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:182 +class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [SpecificValuesChange] a new instance of SpecificValuesChange + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:185 + def initialize(change_details, from, to); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:197 + def description; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:202 + def failure_message; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:192 + def matches?(event_proc); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:210 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:215 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:244 + def after_value_failure; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:238 + def before_value_failure; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:255 + def did_change_failure; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:250 + def did_not_change_failure; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:234 + def matches_after?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:261 + def not_given_a_block_failure; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:221 + def perform_change(event_proc); end +end + +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb:183 +RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject + +# For RSpec 3.1, the base class was named `StartAndEndWith`. For SemVer reasons, +# we still provide this constant until 4.0. +# +# @deprecated Use StartOrEndWith instead. +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:61 +RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith + +# Base class for the `end_with` and `start_with` matchers. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:7 +class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [StartOrEndWith] a new instance of StartOrEndWith + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:8 + def initialize(*expected); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:27 + def description; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:15 + def failure_message; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:36 + def match(_expected, actual); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:48 + def subsets_comparable?; end +end + +# Provides the implementation for `start_with`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:66 +class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:73 + def element_matches?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/start_or_end_with.rb:69 + def subset_matches?; end +end + +# Provides the implementation for `throw_symbol`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:7 +class RSpec::Matchers::BuiltIn::ThrowSymbol + include ::RSpec::Matchers::Composable + + # @api private + # @return [ThrowSymbol] a new instance of ThrowSymbol + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:10 + def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:86 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:68 + def does_not_match?(given_proc); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:103 + def expects_call_stack_jump?; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:74 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:80 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:18 + def matches?(given_proc); end + + # Indicates this matcher matches against a block. + # + # @api private + # @return [True] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:93 + def supports_block_expectations?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:98 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:109 + def actual_result; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:118 + def caught; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:114 + def expected(symbol_desc = T.unsafe(nil)); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/throw_symbol.rb:122 + def throw_description(symbol, arg); end +end + +# Provides the implementation for `yield_control`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:101 +class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::BuiltIn::CountExpectation + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:111 + def does_not_match?(block); end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:117 + def failure_message; end + + # @api private + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:123 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:104 + def matches?(block); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:128 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:133 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:139 + def failure_reason; end +end + +# Object that is yielded to `expect` when one of the +# yield matchers is used. Provides information about +# the yield behavior of the object-under-test. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:12 +class RSpec::Matchers::BuiltIn::YieldProbe + # @return [YieldProbe] a new instance of YieldProbe + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:21 + def initialize(block, &callback); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:68 + def assert_used!; end + + # :nocov: + # On 1.8.7, `lambda { }.arity` and `lambda { |*a| }.arity` both return -1, + # so we can't distinguish between accepting no args and an arg splat. + # It's OK to skip, this, though; it just provides a nice error message + # when the user forgets to accept an arg in their block. They'll still get + # the `assert_used!` error message from above, which is sufficient. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:78 + def assert_valid_expect_block!; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:29 + def has_block?; end + + # Returns the value of attribute num_yields. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:19 + def num_yields; end + + # Sets the attribute num_yields + # + # @param value the value to set the attribute num_yields to. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:19 + def num_yields=(_arg0); end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:33 + def probe; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:53 + def single_yield_args; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:40 + def to_proc; end + + # Returns the value of attribute yielded_args. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:19 + def yielded_args; end + + # Sets the attribute yielded_args + # + # @param value the value to set the attribute yielded_args to. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:19 + def yielded_args=(_arg0); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:57 + def yielded_once?(matcher_name); end + + class << self + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:13 + def probe(block, &callback); end + end +end + +# Provides the implementation for `yield_successive_args`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:296 +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [YieldSuccessiveArgs] a new instance of YieldSuccessiveArgs + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:297 + def initialize(*args); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:337 + def description; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:320 + def does_not_match?(block); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:325 + def failure_message; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:331 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:302 + def matches?(block); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:342 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:347 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:353 + def expected_arg_description; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:365 + def negative_failure_reason; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:357 + def positive_failure_reason; end +end + +# Provides the implementation for `yield_with_args`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:199 +class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @return [YieldWithArgs] a new instance of YieldWithArgs + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:200 + def initialize(*args); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:233 + def description; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:218 + def does_not_match?(block); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:223 + def failure_message; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:228 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:205 + def matches?(block); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:240 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:245 + def supports_value_expectations?; end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:288 + def all_args_match?; end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:273 + def args_currently_match?; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:257 + def expected_arg_description; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:261 + def negative_failure_reason; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:251 + def positive_failure_reason; end +end + +# Provides the implementation for `yield_with_no_args`. +# Not intended to be instantiated directly. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:150 +class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:158 + def does_not_match?(block); end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:163 + def failure_message; end + + # @api private + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:168 + def failure_message_when_negated; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:151 + def matches?(block); end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:173 + def supports_block_expectations?; end + + # @api private + # @private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:178 + def supports_value_expectations?; end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:190 + def negative_failure_reason; end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/built_in/yield.rb:184 + def positive_failure_reason; end +end + +# Mixin designed to support the composable matcher features +# of RSpec 3+. Mix it into your custom matcher classes to +# allow them to be used in a composable fashion. +# +# @api public +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:10 +module RSpec::Matchers::Composable + # Creates a compound `and` expectation. The matcher will + # only pass if both sub-matchers pass. + # This can be chained together to form an arbitrarily long + # chain of matchers. + # + # @api public + # @example + # expect(alphabet).to start_with("a").and end_with("z") + # expect(alphabet).to start_with("a") & end_with("z") + # @note The negative form (`expect(...).not_to matcher.and other`) + # is not supported at this time. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:22 + def &(matcher); end + + # Delegates to `#matches?`. Allows matchers to be used in composable + # fashion and also supports using matchers in case statements. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:45 + def ===(value); end + + # Creates a compound `and` expectation. The matcher will + # only pass if both sub-matchers pass. + # This can be chained together to form an arbitrarily long + # chain of matchers. + # + # @api public + # @example + # expect(alphabet).to start_with("a").and end_with("z") + # expect(alphabet).to start_with("a") & end_with("z") + # @note The negative form (`expect(...).not_to matcher.and other`) + # is not supported at this time. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:22 + def and(matcher); end + + # Creates a compound `or` expectation. The matcher will + # pass if either sub-matcher passes. + # This can be chained together to form an arbitrarily long + # chain of matchers. + # + # @api public + # @example + # expect(stoplight.color).to eq("red").or eq("green").or eq("yellow") + # expect(stoplight.color).to eq("red") | eq("green") | eq("yellow") + # @note The negative form (`expect(...).not_to matcher.or other`) + # is not supported at this time. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:38 + def or(matcher); end + + # Creates a compound `or` expectation. The matcher will + # pass if either sub-matcher passes. + # This can be chained together to form an arbitrarily long + # chain of matchers. + # + # @api public + # @example + # expect(stoplight.color).to eq("red").or eq("green").or eq("yellow") + # expect(stoplight.color).to eq("red") | eq("green") | eq("yellow") + # @note The negative form (`expect(...).not_to matcher.or other`) + # is not supported at this time. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:38 + def |(matcher); end + + private + + # Returns the description of the given object in a way that is + # aware of composed matchers. If the object is a matcher with + # a `description` method, returns the description; otherwise + # returns `object.inspect`. + # + # You are encouraged to use this in your custom matcher's + # `description`, `failure_message` or + # `failure_message_when_negated` implementation if you are + # supporting matcher arguments. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:82 + def description_of(object); end + + # We should enumerate arrays as long as they are not recursive. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:142 + def should_enumerate?(item); end + + # Transforms the given data structue (typically a hash or array) + # into a new data structure that, when `#inspect` is called on it, + # will provide descriptions of any contained matchers rather than + # the normal `#inspect` output. + # + # You are encouraged to use this in your custom matcher's + # `description`, `failure_message` or + # `failure_message_when_negated` implementation if you are + # supporting any arguments which may be a data structure + # containing matchers. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:98 + def surface_descriptions_in(item); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:147 + def unreadable_io?(object); end + + # This provides a generic way to fuzzy-match an expected value against + # an actual value. It understands nested data structures (e.g. hashes + # and arrays) and is able to match against a matcher being used as + # the expected value or within the expected value at any level of + # nesting. + # + # Within a custom matcher you are encouraged to use this whenever your + # matcher needs to match two values, unless it needs more precise semantics. + # For example, the `eq` matcher _does not_ use this as it is meant to + # use `==` (and only `==`) for matching. + # + # @api public + # @param expected [Object] what is expected + # @param actual [Object] the actual value + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:66 + def values_match?(expected, actual); end + + # Historically, a single matcher instance was only checked + # against a single value. Given that the matcher was only + # used once, it's been common to memoize some intermediate + # calculation that is derived from the `actual` value in + # order to reuse that intermediate result in the failure + # message. + # + # This can cause a problem when using such a matcher as an + # argument to another matcher in a composed matcher expression, + # since the matcher instance may be checked against multiple + # values and produce invalid results due to the memoization. + # + # To deal with this, we clone any matchers in `expected` via + # this method when using `values_match?`, so that any memoization + # does not "leak" between checks. + # + # @api public + # @private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:128 + def with_matchers_cloned(object); end + + class << self + # We should enumerate arrays as long as they are not recursive. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:142 + def should_enumerate?(item); end + + # Transforms the given data structue (typically a hash or array) + # into a new data structure that, when `#inspect` is called on it, + # will provide descriptions of any contained matchers rather than + # the normal `#inspect` output. + # + # You are encouraged to use this in your custom matcher's + # `description`, `failure_message` or + # `failure_message_when_negated` implementation if you are + # supporting any arguments which may be a data structure + # containing matchers. + # + # @api public + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:98 + def surface_descriptions_in(item); end + + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:147 + def unreadable_io?(object); end + end +end + +# Wraps an item in order to surface its `description` via `inspect`. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:158 +class RSpec::Matchers::Composable::DescribableItem < ::Struct + # Inspectable version of the item description + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:160 + def inspect; end + + # Returns the value of attribute item + # + # @return [Object] the current value of item + def item; end + + # Sets the attribute item + # + # @param value [Object] the value to set the attribute item to. + # @return [Object] the newly set value + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:158 + def item=(_); end + + # A pretty printed version of the item description. + # + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/composable.rb:165 + def pretty_print(pp); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Defines the custom matcher DSL. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:6 +module RSpec::Matchers::DSL + # Defines a matcher alias. The returned matcher's `description` will be overriden + # to reflect the phrasing of the new name, which will be used in failure messages + # when passed as an argument to another matcher in a composed matcher expression. + # + # @example + # RSpec::Matchers.alias_matcher :a_list_sorted_by, :be_sorted_by do |description| + # description.sub("be sorted by", "a list sorted by") + # end + # + # be_sorted_by(:age).description # => "be sorted by age" + # a_list_sorted_by(:age).description # => "a list sorted by age" + # @example + # RSpec::Matchers.alias_matcher :a_list_that_sums_to, :sum_to + # sum_to(3).description # => "sum to 3" + # a_list_that_sums_to(3).description # => "a list that sums to 3" + # @option options + # @param old_name [Symbol] the original name for the matcher + # @param new_name [Symbol] the new name for the matcher + # @param options [Hash] options for the aliased matcher + # @see RSpec::Matchers + # @yield [String] optional block that, when given, is used to define the overriden + # logic. The yielded arg is the original description or failure message. If no + # block is provided, a default override is used based on the old and new names. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:32 + def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end + + # Defines a custom matcher. + # + # @param name [Symbol] the name for the matcher + # @see RSpec::Matchers + # @yield [Object] block that is used to define the matcher. + # The block is evaluated in the context of your custom matcher class. + # When args are passed to your matcher, they will be yielded here, + # usually representing the expected value(s). + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:72 + def define(name, &declarations); end + + # Defines a negated matcher. The returned matcher's `description` and `failure_message` + # will be overriden to reflect the phrasing of the new name, and the match logic will + # be based on the original matcher but negated. + # + # @example + # RSpec::Matchers.define_negated_matcher :exclude, :include + # include(1, 2).description # => "include 1 and 2" + # exclude(1, 2).description # => "exclude 1 and 2" + # @param negated_name [Symbol] the name for the negated matcher + # @param base_name [Symbol] the name of the original matcher that will be negated + # @see RSpec::Matchers + # @yield [String] optional block that, when given, is used to define the overriden + # logic. The yielded arg is the original description or failure message. If no + # block is provided, a default override is used based on the old and new names. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:60 + def define_negated_matcher(negated_name, base_name, &description_override); end + + # Defines a custom matcher. + # + # @param name [Symbol] the name for the matcher + # @see RSpec::Matchers + # @yield [Object] block that is used to define the matcher. + # The block is evaluated in the context of your custom matcher class. + # When args are passed to your matcher, they will be yielded here, + # usually representing the expected value(s). + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:72 + def matcher(name, &declarations); end + + private + + # :nocov: + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:83 + def warn_about_block_args(name, declarations); end +end + +# Defines default implementations of the matcher +# protocol methods for custom matchers. You can +# override any of these using the {RSpec::Matchers::DSL::Macros Macros} methods +# from within an `RSpec::Matchers.define` block. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:384 +module RSpec::Matchers::DSL::DefaultImplementations + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + + # The default description. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:394 + def description; end + + # Used internally by objects returns by `should` and `should_not`. + # + # @api private + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:389 + def diffable?; end + + # Most matchers do not expect call stack jumps. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:411 + def expects_call_stack_jump?; end + + # Matchers do not support block expectations by default. You + # must opt-in. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:402 + def supports_block_expectations?; end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:406 + def supports_value_expectations?; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:417 + def chained_method_clause_sentences; end +end + +# Contains the methods that are available from within the +# `RSpec::Matchers.define` DSL for creating custom matchers. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:103 +module RSpec::Matchers::DSL::Macros + # Convenience for defining methods on this matcher to create a fluent + # interface. The trick about fluent interfaces is that each method must + # return self in order to chain methods together. `chain` handles that + # for you. If the method is invoked and the + # `include_chain_clauses_in_custom_matcher_descriptions` config option + # hash been enabled, the chained method name and args will be added to the + # default description and failure message. + # + # In the common case where you just want the chained method to store some + # value(s) for later use (e.g. in `match`), you can provide one or more + # attribute names instead of a block; the chained method will store its + # arguments in instance variables with those names, and the values will + # be exposed via getters. + # + # @example + # + # RSpec::Matchers.define :have_errors_on do |key| + # chain :with do |message| + # @message = message + # end + # + # match do |actual| + # actual.errors[key] == @message + # end + # end + # + # expect(minor).to have_errors_on(:age).with("Not old enough to participate") + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:297 + def chain(method_name, *attr_names, &definition); end + + # Customize the description to use for one-liners. Only use this when + # the description generated by default doesn't suit your needs. + # + # @example + # + # RSpec::Matchers.define :qualify_for do |expected| + # match { your_match_logic } + # + # description do + # "qualify for #{expected}" + # end + # end + # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:252 + def description(&definition); end + + # Tells the matcher to diff the actual and expected values in the failure + # message. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:258 + def diffable; end + + # Customizes the failure messsage to use when this matcher is + # asked to positively match. Only use this when the message + # generated by default doesn't suit your needs. + # + # @example + # + # RSpec::Matchers.define :have_strength do |expected| + # match { your_match_logic } + # + # failure_message do |actual| + # "Expected strength of #{expected}, but had #{actual.strength}" + # end + # end + # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:215 + def failure_message(&definition); end + + # Customize the failure messsage to use when this matcher is asked + # to negatively match. Only use this when the message generated by + # default doesn't suit your needs. + # + # @example + # + # RSpec::Matchers.define :have_strength do |expected| + # match { your_match_logic } + # + # failure_message_when_negated do |actual| + # "Expected not to have strength of #{expected}, but did" + # end + # end + # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:234 + def failure_message_when_negated(&definition); end + + # Stores the block that is used to determine whether this matcher passes + # or fails. The block should return a boolean value. When the matcher is + # passed to `expect(...).to` and the block returns `true`, then the expectation + # passes. Similarly, when the matcher is passed to `expect(...).not_to` and the + # block returns `false`, then the expectation passes. + # + # By default the match block will swallow expectation errors (e.g. + # caused by using an expectation such as `expect(1).to eq 2`), if you + # with to allow these to bubble up, pass in the option + # `:notify_expectation_failures => true`. + # + # @example + # + # RSpec::Matchers.define :be_even do + # match do |actual| + # actual.even? + # end + # end + # + # expect(4).to be_even # passes + # expect(3).not_to be_even # passes + # expect(3).to be_even # fails + # expect(4).not_to be_even # fails + # @param options [Hash] for defining the behavior of the match block. + # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:130 + def match(options = T.unsafe(nil), &match_block); end + + # Use this instead of `match` when the block will raise an exception + # rather than returning false to indicate a failure. + # + # @example + # + # RSpec::Matchers.define :accept_as_valid do |candidate_address| + # match_unless_raises ValidationException do |validator| + # validator.validate(candidate_address) + # end + # end + # + # expect(email_validator).to accept_as_valid("person@company.com") + # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:187 + def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end + + # Use this to define the block for a negative expectation (`expect(...).not_to`) + # when the positive and negative forms require different handling. This + # is rarely necessary, but can be helpful, for example, when specifying + # asynchronous processes that require different timeouts. + # + # By default the match block will swallow expectation errors (e.g. + # caused by using an expectation such as `expect(1).to eq 2`), if you + # with to allow these to bubble up, pass in the option + # `:notify_expectation_failures => true`. + # + # @param options [Hash] for defining the behavior of the match block. + # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:159 + def match_when_negated(options = T.unsafe(nil), &match_block); end + + # Declares that the matcher can be used in a block expectation. + # Users will not be able to use your matcher in a block + # expectation without declaring this. + # (e.g. `expect { do_something }.to matcher`). + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:266 + def supports_block_expectations; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:311 + def assign_attributes(attr_names); end + + # Does the following: + # + # - Defines the named method using a user-provided block + # in @user_method_defs, which is included as an ancestor + # in the singleton class in which we eval the `define` block. + # - Defines an overriden definition for the same method + # usign the provided `our_def` block. + # - Provides a default `our_def` block for the common case + # of needing to call the user's definition with `@actual` + # as an arg, but only if their block's arity can handle it. + # + # This compiles the user block into an actual method, allowing + # them to use normal method constructs like `return` + # (e.g. for an early guard statement), while allowing us to define + # an override that can provide the wrapped handling + # (e.g. assigning `@actual`, rescueing errors, etc) and + # can `super` to the user's definition. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:345 + def define_user_override(method_name, user_def, &our_def); end +end + +# Defines deprecated macro methods from RSpec 2 for backwards compatibility. +# +# @deprecated Use the methods from {Macros} instead. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:353 +module RSpec::Matchers::DSL::Macros::Deprecated + # @deprecated Use {Macros#failure_message} instead. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:367 + def failure_message_for_should(&definition); end + + # @deprecated Use {Macros#failure_message_when_negated} instead. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:373 + def failure_message_for_should_not(&definition); end + + # @deprecated Use {Macros#match} instead. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:355 + def match_for_should(&definition); end + + # @deprecated Use {Macros#match_when_negated} instead. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:361 + def match_for_should_not(&definition); end +end + +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:145 +RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc) + +# The class used for custom matchers. The block passed to +# `RSpec::Matchers.define` will be evaluated in the context +# of the singleton class of an instance, and will have the +# {RSpec::Matchers::DSL::Macros Macros} methods available. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:432 +class RSpec::Matchers::DSL::Matcher + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + include ::RSpec::Matchers::DSL::DefaultImplementations + include ::RSpec::Matchers + include ::RSpec::Matchers::Composable + extend ::RSpec::Matchers::DSL::Macros + extend ::RSpec::Matchers::DSL::Macros::Deprecated + + # @api private + # @return [Matcher] a new instance of Matcher + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:461 + def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end + + # Exposes the value being matched against -- generally the object + # object wrapped by `expect`. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:448 + def actual; end + + # The block parameter used in the expectation + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:455 + def block_arg; end + + # Provides the expected value. This will return an array if + # multiple arguments were passed to the matcher; otherwise it + # will return a single value. + # + # @see #expected_as_array + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:481 + def expected; end + + # Returns the expected value as an an array. This exists primarily + # to aid in upgrading from RSpec 2.x, since in RSpec 2, `expected` + # always returned an array. + # + # @see #expected + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:493 + def expected_as_array; end + + # Adds the name (rather than a cryptic hex number) + # so we can identify an instance of + # the matcher in error messages (e.g. for `NoMethodError`) + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:498 + def inspect; end + + # The name of the matcher. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:458 + def name; end + + # Exposes the exception raised during the matching by `match_unless_raises`. + # Could be useful to extract details for a failure message. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:452 + def rescued_exception; end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:521 + def actual_arg_for(block); end + + # Takes care of forwarding unhandled messages to the + # `@matcher_execution_context` (typically the current + # running `RSpec::Core::Example`). This is needed by + # rspec-rails so that it can define matchers that wrap + # Rails' test helper methods, but it's also a useful + # feature in its own right. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:531 + def method_missing(method, *args, &block); end + + # Indicates that this matcher responds to messages + # from the `@matcher_execution_context` as well. + # Also, supports getting a method object for such methods. + # + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/dsl.rb:506 + def respond_to_missing?(method, include_private = T.unsafe(nil)); end +end + +# source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:956 +RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp) + +# Facilitates converting ruby objects to English phrases. +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/english_phrasing.rb:4 +module RSpec::Matchers::EnglishPhrasing + class << self + # when given an empty list. + # + # Converts an object (often a collection of objects) + # into an English list. + # + # list(['banana', 'kiwi', 'mango']) + # #=> " \"banana\", \"kiwi\", and \"mango\"" + # + # Given an empty collection, returns the empty string. + # + # list([]) #=> "" + # + # @note The returned string has a leading space except + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/english_phrasing.rb:26 + def list(obj); end + + # Converts a symbol into an English expression. + # + # split_words(:banana_creme_pie) #=> "banana creme pie" + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/english_phrasing.rb:9 + def split_words(sym); end + end +end + +# Handles list of expected values when there is a need to render +# multiple diffs. Also can handle one value. +# +# @api private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:6 +class RSpec::Matchers::ExpectedsForMultipleDiffs + # @api private + # @return [ExpectedsForMultipleDiffs] a new instance of ExpectedsForMultipleDiffs + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:16 + def initialize(expected_list); end + + # Returns message with diff(s) appended for provided differ + # factory and actual value if there are any + # + # @api private + # @param message [String] original failure message + # @param differ [Proc] + # @param actual [Any] value + # @return [String] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:47 + def message_with_diff(message, differ, actual); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:68 + def diffs(differ, actual); end + + class << self + # Wraps provided matcher list in instance of + # ExpectedForMultipleDiffs. + # + # @api private + # @param matchers [Array<Any>] list of matchers to wrap + # @return [RSpec::Matchers::ExpectedsForMultipleDiffs] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:36 + def for_many_matchers(matchers); end + + # Wraps provided expected value in instance of + # ExpectedForMultipleDiffs. If provided value is already an + # ExpectedForMultipleDiffs then it just returns it. + # + # @api private + # @param expected [Any] value to be wrapped + # @return [RSpec::Matchers::ExpectedsForMultipleDiffs] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:26 + def from(expected); end + + private + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:58 + def diff_label_for(matcher); end + + # @api private + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:62 + def truncated(description); end + end +end + +# Default diff label when there is only one matcher in diff +# output +# +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:10 +RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String) + +# Maximum readable matcher description length +# +# @api private +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/expecteds_for_multiple_diffs.rb:14 +RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rspec-expectations-3.11.0/lib/rspec/matchers.rb:955 +RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp) + +# Provides the necessary plumbing to wrap a matcher with a decorator. +# +# @private +# +# source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:5 +class RSpec::Matchers::MatcherDelegator + include ::RSpec::Matchers::Composable + + # @return [MatcherDelegator] a new instance of MatcherDelegator + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:9 + def initialize(base_matcher); end + + # Returns the value of attribute base_matcher. + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:7 + def base_matcher; end + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:13 + def method_missing(*args, &block); end + + private + + # source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:29 + def initialize_copy(other); end + + # @return [Boolean] + # + # source://rspec-expectations-3.11.0/lib/rspec/matchers/matcher_delegator.rb:18 + def respond_to_missing?(name, include_all = T.unsafe(nil)); end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:54 +RSpec::SharedContext = RSpec::Core::SharedContext diff --git a/sorbet/rbi/gems/rspec-mocks.rbi b/sorbet/rbi/gems/rspec-mocks.rbi deleted file mode 100644 index 6d49be55..00000000 --- a/sorbet/rbi/gems/rspec-mocks.rbi +++ /dev/null @@ -1,1103 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi -# -# rspec-mocks-3.11.1 - -module RSpec -end -module RSpec::Mocks - def self.allow_message(subject, message, opts = nil, &block); end - def self.configuration; end - def self.error_generator; end - def self.expect_message(subject, message, opts = nil, &block); end - def self.setup; end - def self.space; end - def self.teardown; end - def self.verify; end - def self.with_temporary_scope; end -end -class RSpec::Mocks::InstanceMethodStasher - def handle_restoration_failures; end - def initialize(object, method); end - def method_defined_directly_on_klass?; end - def method_defined_on_klass?(klass = nil); end - def method_is_stashed?; end - def method_owned_by_klass?; end - def original_method; end - def restore; end - def stash; end -end -class RSpec::Mocks::MethodDouble - def add_default_stub(*args, &implementation); end - def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end - def add_simple_expectation(method_name, response, error_generator, backtrace_line); end - def add_simple_stub(method_name, response); end - def add_stub(error_generator, expectation_ordering, expected_from, opts = nil, &implementation); end - def build_expectation(error_generator, expectation_ordering); end - def clear; end - def configure_method; end - def define_proxy_method; end - def definition_target; end - def expectations; end - def initialize(object, method_name, proxy); end - def message_expectation_class; end - def method_name; end - def method_stasher; end - def new_rspec_prepended_module; end - def object; end - def object_singleton_class; end - def original_implementation_callable; end - def original_method; end - def proxy_method_invoked(_obj, *args, &block); end - def raise_method_not_stubbed_error; end - def remove_method_from_definition_target; end - def remove_stub; end - def remove_stub_if_present; end - def reset; end - def restore_original_method; end - def restore_original_visibility; end - def save_original_implementation_callable!; end - def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil); end - def show_frozen_warning; end - def stubs; end - def usable_rspec_prepended_module; end - def verify; end - def visibility; end -end -class RSpec::Mocks::MethodDouble::RSpecPrependedModule < Module -end -module RSpec::Mocks::ArgumentMatchers - def a_kind_of(klass); end - def an_instance_of(klass); end - def any_args; end - def anything; end - def array_including(*args); end - def boolean; end - def duck_type(*args); end - def hash_excluding(*args); end - def hash_including(*args); end - def hash_not_including(*args); end - def instance_of(klass); end - def kind_of(klass); end - def no_args; end - def self.anythingize_lonely_keys(*args); end -end -class RSpec::Mocks::ArgumentMatchers::SingletonMatcher - def self.inherited(subklass); end - def self.new(*arg0); end -end -class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher - def description; end -end -class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher - def ===(_other); end - def description; end -end -class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher - def description; end -end -class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher - def ===(value); end - def description; end -end -class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher - def ===(predicate, actual); end - def description(name); end - def formatted_expected_hash; end - def initialize(expected); end -end -class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher - def ===(actual); end - def description; end -end -class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher - def ===(actual); end - def description; end -end -class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher - def ===(actual); end - def description; end - def formatted_expected_values; end - def initialize(expected); end -end -class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher - def ===(value); end - def description; end - def initialize(*methods_to_respond_to); end -end -class RSpec::Mocks::ArgumentMatchers::InstanceOf - def ===(actual); end - def description; end - def initialize(klass); end -end -class RSpec::Mocks::ArgumentMatchers::KindOf - def ===(actual); end - def description; end - def initialize(klass); end -end -class RSpec::Mocks::ObjectReference - def self.anonymous_module?(mod); end - def self.for(object_module_or_name, allow_direct_object_refs = nil); end - def self.name_of(mod); end -end -class RSpec::Mocks::DirectObjectReference - def const_to_replace; end - def defined?; end - def description; end - def initialize(object); end - def target; end - def when_loaded; end -end -class RSpec::Mocks::NamedObjectReference - def const_to_replace; end - def defined?; end - def description; end - def initialize(const_name); end - def object; end - def target; end - def when_loaded; end -end -module RSpec::Mocks::ExampleMethods - def allow(target); end - def allow_any_instance_of(klass); end - def allow_message_expectations_on_nil; end - def class_double(doubled_class, *args); end - def class_spy(*args); end - def double(*args); end - def expect_any_instance_of(klass); end - def have_received(method_name, &block); end - def hide_const(constant_name); end - def instance_double(doubled_class, *args); end - def instance_spy(*args); end - def object_double(object_or_name, *args); end - def object_spy(*args); end - def receive(method_name, &block); end - def receive_message_chain(*messages, &block); end - def receive_messages(message_return_value_hash); end - def self.declare_double(type, *args); end - def self.declare_verifying_double(type, ref, *args); end - def self.extended(object); end - def self.included(klass); end - def spy(*args); end - def stub_const(constant_name, value, options = nil); end - def without_partial_double_verification; end - include RSpec::Mocks::ArgumentMatchers -end -module RSpec::Mocks::ExampleMethods::ExpectHost - def expect(target); end -end -class RSpec::Mocks::Proxy - def add_message_expectation(method_name, opts = nil, &block); end - def add_simple_expectation(method_name, response, location); end - def add_simple_stub(method_name, response); end - def add_stub(method_name, opts = nil, &implementation); end - def as_null_object; end - def build_expectation(method_name); end - def check_for_unexpected_arguments(expectation); end - def ensure_can_be_proxied!(object); end - def ensure_implemented(*_args); end - def find_almost_matching_expectation(method_name, *args); end - def find_almost_matching_stub(method_name, *args); end - def find_best_matching_expectation_for(method_name); end - def find_matching_expectation(method_name, *args); end - def find_matching_method_stub(method_name, *args); end - def has_negative_expectation?(message); end - def initialize(object, order_group, options = nil); end - def message_received(message, *args, &block); end - def messages_arg_list; end - def method_double_for(message); end - def method_double_if_exists_for_message(message); end - def null_object?; end - def object; end - def original_method_handle_for(_message); end - def prepended_modules_of_singleton_class; end - def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end - def raise_unexpected_message_error(method_name, args); end - def received_message?(method_name, *args, &block); end - def record_message_received(message, *args, &block); end - def remove_stub(method_name); end - def remove_stub_if_present(method_name); end - def replay_received_message_on(expectation, &block); end - def reset; end - def self.prepended_modules_of(klass); end - def verify; end - def visibility_for(_method_name); end -end -class RSpec::Mocks::Proxy::SpecificMessage < Struct - def ==(expectation); end - def args; end - def args=(_); end - def message; end - def message=(_); end - def object; end - def object=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Mocks::TestDoubleProxy < RSpec::Mocks::Proxy - def reset; end -end -class RSpec::Mocks::PartialDoubleProxy < RSpec::Mocks::Proxy - def add_simple_expectation(method_name, response, location); end - def add_simple_stub(method_name, response); end - def any_instance_class_recorder_observing_method?(klass, method_name); end - def message_received(message, *args, &block); end - def original_method_handle_for(message); end - def reset; end - def visibility_for(method_name); end -end -module RSpec::Mocks::PartialClassDoubleProxyMethods - def initialize(source_space, *args); end - def method_double_from_ancestor_for(message); end - def original_method_handle_for(message); end - def original_unbound_method_handle_from_ancestor_for(message); end - def superclass_proxy; end -end -class RSpec::Mocks::PartialClassDoubleProxy < RSpec::Mocks::PartialDoubleProxy - include RSpec::Mocks::PartialClassDoubleProxyMethods -end -class RSpec::Mocks::ProxyForNil < RSpec::Mocks::PartialDoubleProxy - def add_message_expectation(method_name, opts = nil, &block); end - def add_stub(method_name, opts = nil, &implementation); end - def disallow_expectations; end - def disallow_expectations=(arg0); end - def initialize(order_group); end - def raise_error(method_name); end - def set_expectation_behavior; end - def warn(method_name); end - def warn_about_expectations; end - def warn_about_expectations=(arg0); end - def warn_or_raise!(method_name); end -end -module RSpec::Mocks::TestDouble - def ==(other); end - def __build_mock_proxy(order_group); end - def __build_mock_proxy_unless_expired(order_group); end - def __disallow_further_usage!; end - def __mock_proxy; end - def __raise_expired_error; end - def as_null_object; end - def assign_stubs(stubs); end - def freeze; end - def initialize(name = nil, stubs = nil); end - def initialize_copy(other); end - def inspect; end - def method_missing(message, *args, &block); end - def null_object?; end - def respond_to?(message, incl_private = nil); end - def to_s; end -end -class RSpec::Mocks::Double - include RSpec::Mocks::TestDouble -end -module RSpec::Mocks::TestDoubleFormatter - def self.format(dbl, unwrap = nil); end - def self.name_desc(dbl); end - def self.type_desc(dbl); end - def self.verified_module_desc(dbl); end -end -class RSpec::Mocks::ArgumentListMatcher - def args_match?(*actual_args); end - def ensure_expected_args_valid!; end - def expected_args; end - def initialize(*expected_args); end - def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end - def resolve_expected_args_based_on(actual_args); end -end -class RSpec::Mocks::SimpleMessageExpectation - def called_max_times?; end - def initialize(message, response, error_generator, backtrace_line = nil); end - def invoke(*_); end - def matches?(message, *_); end - def unadvise(_); end - def verify_messages_received; end -end -class RSpec::Mocks::MessageExpectation - def and_call_original; end - def and_invoke(first_proc, *procs); end - def and_raise(*args); end - def and_return(first_value, *values); end - def and_throw(*args); end - def and_wrap_original(&block); end - def and_yield(*args, &block); end - def at_least(n, &block); end - def at_most(n, &block); end - def exactly(n, &block); end - def inspect; end - def never; end - def once(&block); end - def ordered(&block); end - def thrice(&block); end - def time(&block); end - def times(&block); end - def to_s; end - def twice(&block); end - def with(*args, &block); end - include RSpec::Mocks::MessageExpectation::ImplementationDetails -end -module RSpec::Mocks::MessageExpectation::ImplementationDetails - def actual_received_count_matters?; end - def additional_expected_calls; end - def advise(*args); end - def and_yield_receiver_to_implementation; end - def argument_list_matcher=(arg0); end - def called_max_times?; end - def description_for(verb); end - def ensure_expected_ordering_received!; end - def error_generator; end - def error_generator=(arg0); end - def exception_source_id; end - def expectation_count_type; end - def expected_args; end - def expected_from=(arg0); end - def expected_messages_received?; end - def expected_received_count=(arg0); end - def generate_error; end - def has_been_invoked?; end - def ignoring_args?; end - def implementation; end - def implementation=(arg0); end - def increase_actual_received_count!; end - def initial_implementation_action=(action); end - def initialize(error_generator, expectation_ordering, expected_from, method_double, type = nil, opts = nil, &implementation_block); end - def inner_implementation_action=(action); end - def invoke(parent_stub, *args, &block); end - def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end - def invoke_without_incrementing_received_count(parent_stub, *args, &block); end - def matches?(message, *args); end - def matches_at_least_count?; end - def matches_at_most_count?; end - def matches_exact_count?; end - def matches_name_but_not_args(message, *args); end - def message; end - def negative?; end - def negative_expectation_for?(message); end - def ordered?; end - def orig_object; end - def raise_already_invoked_error_if_necessary(calling_customization); end - def raise_out_of_order_error; end - def raise_unexpected_message_args_error(args_for_multiple_calls); end - def safe_invoke(parent_stub, *args, &block); end - def set_expected_received_count(relativity, n); end - def similar_messages; end - def terminal_implementation_action=(action); end - def type; end - def unadvise(args); end - def verify_messages_received; end - def warn_about_stub_override; end - def wrap_original(method_name, &block); end - def yield_receiver_to_implementation_block?; end -end -class RSpec::Mocks::AndYieldImplementation - def call(*_args_to_ignore, &block); end - def initialize(args_to_yield, eval_context, error_generator); end -end -class RSpec::Mocks::AndReturnImplementation - def call(*_args_to_ignore, &_block); end - def initialize(values_to_return); end -end -class RSpec::Mocks::AndInvokeImplementation - def call(*args, &block); end - def initialize(procs_to_invoke); end -end -class RSpec::Mocks::Implementation - def actions; end - def call(*args, &block); end - def initial_action; end - def initial_action=(arg0); end - def inner_action; end - def inner_action=(arg0); end - def present?; end - def terminal_action; end - def terminal_action=(arg0); end -end -class RSpec::Mocks::AndWrapOriginalImplementation - def call(*args, &block); end - def cannot_modify_further_error; end - def initial_action=(_value); end - def initialize(method, block); end - def inner_action; end - def inner_action=(_value); end - def present?; end - def terminal_action=(_value); end -end -class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < StandardError -end -class RSpec::Mocks::OrderGroup - def clear; end - def consume; end - def empty?; end - def expectation_for(message); end - def expectations_invoked_in_order?; end - def expected_invocations; end - def handle_order_constraint(expectation); end - def initialize; end - def invoked(message); end - def invoked_expectations; end - def ready_for?(expectation); end - def register(expectation); end - def remaining_expectations; end - def verify_invocation_order(expectation); end -end -class RSpec::Mocks::MockExpectationError < Exception -end -class RSpec::Mocks::ExpiredTestDoubleError < RSpec::Mocks::MockExpectationError -end -class RSpec::Mocks::OutsideOfExampleError < StandardError -end -class RSpec::Mocks::MockExpectationAlreadyInvokedError < Exception -end -class RSpec::Mocks::CannotSupportArgMutationsError < StandardError -end -class RSpec::Mocks::UnsupportedMatcherError < StandardError -end -class RSpec::Mocks::NegationUnsupportedError < StandardError -end -class RSpec::Mocks::VerifyingDoubleNotDefinedError < StandardError -end -class RSpec::Mocks::ErrorGenerator - def __raise(message, backtrace_line = nil, source_id = nil); end - def arg_list(args); end - def count_message(count, expectation_count_type = nil); end - def default_error_message(expectation, expected_args, actual_args); end - def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end - def diff_message(expected_args, actual_args); end - def differ; end - def error_message(expectation, args_for_multiple_calls); end - def expectation_on_nil_message(method_name); end - def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end - def format_args(args); end - def format_received_args(args_for_multiple_calls); end - def group_count(index, args); end - def grouped_args(args); end - def initialize(target = nil); end - def intro(unwrapped = nil); end - def list_of_exactly_one_string?(args); end - def method_call_args_description(args, generic_prefix = nil, matcher_prefix = nil); end - def notify(*args); end - def opts; end - def opts=(arg0); end - def prepend_to_backtrace(exception, line); end - def raise_already_invoked_error(message, calling_customization); end - def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end - def raise_double_negation_error(wrapped_expression); end - def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = nil, source_id = nil); end - def raise_expectation_on_mocked_method(method); end - def raise_expectation_on_nil_error(method_name); end - def raise_expectation_on_unstubbed_method(method); end - def raise_expired_test_double_error; end - def raise_have_received_disallowed(type, reason); end - def raise_invalid_arguments_error(verifier); end - def raise_method_not_stubbed_error(method_name); end - def raise_missing_block_error(args_to_yield); end - def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end - def raise_non_public_error(method_name, visibility); end - def raise_only_valid_on_a_partial_double(method); end - def raise_out_of_order_error(message); end - def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = nil); end - def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = nil); end - def raise_unexpected_message_error(message, args); end - def raise_unimplemented_error(doubled_module, method_name, object); end - def raise_verifying_double_not_defined_error(ref); end - def raise_wrong_arity_error(args_to_yield, signature); end - def received_part_of_expectation_error(actual_received_count, args); end - def times(count); end - def unexpected_arguments_message(expected_args_string, actual_args_string); end - def unpack_string_args(formatted_expected_args, actual_args); end -end -class RSpec::Mocks::RootSpace - def any_instance_proxy_for(*_args); end - def any_instance_recorder_for(*_args); end - def any_instance_recorders_from_ancestry_of(_object); end - def new_scope; end - def proxy_for(*_args); end - def raise_lifecycle_message; end - def register_constant_mutator(_mutator); end - def registered?(_object); end - def reset_all; end - def superclass_proxy_for(*_args); end - def verify_all; end -end -class RSpec::Mocks::Space - def any_instance_mutex; end - def any_instance_proxy_for(klass); end - def any_instance_recorder_for(klass, only_return_existing = nil); end - def any_instance_recorder_not_found_for(id, klass); end - def any_instance_recorders; end - def any_instance_recorders_from_ancestry_of(object); end - def class_proxy_with_callback_verification_strategy(object, strategy); end - def constant_mutator_for(name); end - def ensure_registered(object); end - def id_for(object); end - def initialize; end - def new_mutex; end - def new_scope; end - def proxies; end - def proxies_of(klass); end - def proxy_for(object); end - def proxy_mutex; end - def proxy_not_found_for(id, object); end - def register_constant_mutator(mutator); end - def registered?(object); end - def reset_all; end - def superclass_proxy_for(klass); end - def superclass_proxy_not_found_for(id, object); end - def verify_all; end -end -class RSpec::Mocks::NestedSpace < RSpec::Mocks::Space - def any_instance_recorder_not_found_for(id, klass); end - def constant_mutator_for(name); end - def initialize(parent); end - def proxies_of(klass); end - def proxy_not_found_for(id, object); end - def registered?(object); end -end -class RSpec::Mocks::Constant - def hidden=(arg0); end - def hidden?; end - def initialize(name); end - def inspect; end - def mutated?; end - def name; end - def original_value; end - def original_value=(arg0); end - def previously_defined=(arg0); end - def previously_defined?; end - def self.original(name); end - def self.unmutated(name); end - def stubbed=(arg0); end - def stubbed?; end - def to_s; end - def valid_name=(arg0); end - def valid_name?; end - extend RSpec::Support::RecursiveConstMethods -end -class RSpec::Mocks::ConstantMutator - def self.hide(constant_name); end - def self.mutate(mutator); end - def self.raise_on_invalid_const; end - def self.stub(constant_name, value, options = nil); end - extend RSpec::Support::RecursiveConstMethods -end -class RSpec::Mocks::ConstantMutator::BaseMutator - def full_constant_name; end - def idempotently_reset; end - def initialize(full_constant_name, mutated_value, transfer_nested_constants); end - def original_value; end - def to_constant; end - include RSpec::Support::RecursiveConstMethods -end -class RSpec::Mocks::ConstantMutator::ConstantHider < RSpec::Mocks::ConstantMutator::BaseMutator - def mutate; end - def reset; end - def to_constant; end -end -class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < RSpec::Mocks::ConstantMutator::BaseMutator - def initialize(*args); end - def mutate; end - def reset; end - def should_transfer_nested_constants?; end - def to_constant; end - def transfer_nested_constants; end - def verify_constants_to_transfer!; end -end -class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < RSpec::Mocks::ConstantMutator::BaseMutator - def mutate; end - def name_for(parent, name); end - def reset; end - def to_constant; end -end -module RSpec::Mocks::TargetDelegationClassMethods - def delegate_not_to(matcher_method, options = nil); end - def delegate_to(matcher_method); end - def disallow_negation(method_name); end -end -module RSpec::Mocks::TargetDelegationInstanceMethods - def define_matcher(matcher, name, &block); end - def matcher_allowed?(matcher); end - def raise_negation_unsupported(method_name, matcher); end - def raise_unsupported_matcher(method_name, matcher); end - def target; end -end -class RSpec::Mocks::TargetBase - def initialize(target); end - extend RSpec::Mocks::TargetDelegationClassMethods - include RSpec::Mocks::TargetDelegationInstanceMethods -end -module RSpec::Mocks::ExpectationTargetMethods - def expression; end - def not_to(matcher, &block); end - def to(matcher, &block); end - def to_not(matcher, &block); end - extend RSpec::Mocks::TargetDelegationClassMethods - include RSpec::Mocks::TargetDelegationInstanceMethods -end -class RSpec::Mocks::ExpectationTarget < RSpec::Mocks::TargetBase - include RSpec::Mocks::ExpectationTargetMethods -end -class RSpec::Mocks::AllowanceTarget < RSpec::Mocks::TargetBase - def expression; end - def not_to(matcher, *_args); end - def to(matcher, &block); end - def to_not(matcher, *_args); end -end -class RSpec::Mocks::AnyInstanceAllowanceTarget < RSpec::Mocks::TargetBase - def expression; end - def not_to(matcher, *_args); end - def to(matcher, &block); end - def to_not(matcher, *_args); end -end -class RSpec::Mocks::AnyInstanceExpectationTarget < RSpec::Mocks::TargetBase - def expression; end - def not_to(matcher, &block); end - def to(matcher, &block); end - def to_not(matcher, &block); end -end -module RSpec::Mocks::Syntax - def self.default_should_syntax_host; end - def self.disable_expect(syntax_host = nil); end - def self.disable_should(syntax_host = nil); end - def self.enable_expect(syntax_host = nil); end - def self.enable_should(syntax_host = nil); end - def self.expect_enabled?(syntax_host = nil); end - def self.should_enabled?(syntax_host = nil); end - def self.warn_about_should!; end - def self.warn_unless_should_configured(method_name, replacement = nil); end -end -class BasicObject - def as_null_object; end - def null_object?; end - def received_message?(message, *args, &block); end - def should_not_receive(message, &block); end - def should_receive(message, opts = nil, &block); end - def stub(message_or_hash, opts = nil, &block); end - def stub_chain(*chain, &blk); end - def unstub(message); end -end -class Class < Module - def any_instance; end -end -class RSpec::Mocks::Configuration - def add_stub_and_should_receive_to(*modules); end - def allow_message_expectations_on_nil; end - def allow_message_expectations_on_nil=(arg0); end - def before_verifying_doubles(&block); end - def color?; end - def initialize; end - def patch_marshal_to_support_partial_doubles=(val); end - def reset_syntaxes_to_default; end - def syntax; end - def syntax=(*values); end - def temporarily_suppress_partial_double_verification; end - def temporarily_suppress_partial_double_verification=(arg0); end - def transfer_nested_constants=(arg0); end - def transfer_nested_constants?; end - def verify_doubled_constant_names=(arg0); end - def verify_doubled_constant_names?; end - def verify_partial_doubles=(val); end - def verify_partial_doubles?; end - def verifying_double_callbacks; end - def when_declaring_verifying_double(&block); end - def yield_receiver_to_any_instance_implementation_blocks=(arg0); end - def yield_receiver_to_any_instance_implementation_blocks?; end -end -class RSpec::Mocks::VerifyingMessageExpectation < RSpec::Mocks::MessageExpectation - def initialize(*args); end - def method_reference; end - def method_reference=(arg0); end - def validate_expected_arguments!; end - def with(*args, &block); end -end -class RSpec::Mocks::MethodReference - def defined?; end - def implemented?; end - def initialize(object_reference, method_name); end - def original_method; end - def self.for(object_reference, method_name); end - def self.instance_method_visibility_for(klass, method_name); end - def self.method_defined_at_any_visibility?(klass, method_name); end - def self.method_visibility_for(object, method_name); end - def unimplemented?; end - def visibility; end - def with_signature; end -end -class RSpec::Mocks::InstanceMethodReference < RSpec::Mocks::MethodReference - def find_method(mod); end - def method_defined?(mod); end - def method_implemented?(mod); end - def visibility_from(mod); end -end -class RSpec::Mocks::ObjectMethodReference < RSpec::Mocks::MethodReference - def find_method(object); end - def method_defined?(object); end - def method_implemented?(object); end - def self.for(object_reference, method_name); end - def visibility_from(object); end -end -class RSpec::Mocks::ClassNewMethodReference < RSpec::Mocks::ObjectMethodReference - def self.applies_to?(method_name); end - def with_signature; end -end -class RSpec::Mocks::CallbackInvocationStrategy - def call(doubled_module); end -end -class RSpec::Mocks::NoCallbackInvocationStrategy - def call(_doubled_module); end -end -module RSpec::Mocks::VerifyingProxyMethods - def add_message_expectation(method_name, opts = nil, &block); end - def add_simple_stub(method_name, *args); end - def add_stub(method_name, opts = nil, &implementation); end - def ensure_implemented(method_name); end - def ensure_publicly_implemented(method_name, _object); end -end -class RSpec::Mocks::VerifyingProxy < RSpec::Mocks::TestDoubleProxy - def initialize(object, order_group, doubled_module, method_reference_class); end - def method_reference; end - def validate_arguments!(method_name, args); end - def visibility_for(method_name); end - include RSpec::Mocks::VerifyingProxyMethods -end -class RSpec::Mocks::VerifyingPartialDoubleProxy < RSpec::Mocks::PartialDoubleProxy - def ensure_implemented(_method_name); end - def initialize(object, expectation_ordering, optional_callback_invocation_strategy = nil); end - def method_reference; end - include RSpec::Mocks::VerifyingProxyMethods -end -class RSpec::Mocks::VerifyingPartialClassDoubleProxy < RSpec::Mocks::VerifyingPartialDoubleProxy - include RSpec::Mocks::PartialClassDoubleProxyMethods -end -class RSpec::Mocks::VerifyingMethodDouble < RSpec::Mocks::MethodDouble - def add_expectation(*args, &block); end - def add_stub(*args, &block); end - def initialize(object, method_name, proxy, method_reference); end - def message_expectation_class; end - def proxy_method_invoked(obj, *args, &block); end - def validate_arguments!(actual_args); end -end -class RSpec::Mocks::VerifyingExistingMethodDouble < RSpec::Mocks::VerifyingMethodDouble - def initialize(object, method_name, proxy); end - def self.for(object, method_name, proxy); end - def unimplemented?; end - def with_signature; end -end -class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < RSpec::Mocks::VerifyingExistingMethodDouble - def with_signature; end -end -module RSpec::Mocks::VerifyingDouble - def __send__(name, *args, &block); end - def initialize(doubled_module, *args); end - def method_missing(message, *args, &block); end - def respond_to?(message, include_private = nil); end - def send(name, *args, &block); end -end -class RSpec::Mocks::InstanceVerifyingDouble - def __build_mock_proxy(order_group); end - include RSpec::Mocks::TestDouble - include RSpec::Mocks::VerifyingDouble -end -module RSpec::Mocks::ObjectVerifyingDoubleMethods - def __build_mock_proxy(order_group); end - def as_stubbed_const(options = nil); end - include RSpec::Mocks::TestDouble - include RSpec::Mocks::VerifyingDouble -end -class RSpec::Mocks::ObjectVerifyingDouble - include RSpec::Mocks::ObjectVerifyingDoubleMethods -end -class RSpec::Mocks::ClassVerifyingDouble < Module - include RSpec::Mocks::ObjectVerifyingDoubleMethods -end -module RSpec::Mocks::Version -end -module RSpec::Support - def self.require_rspec_mocks(f); end -end -module RSpec::Mocks::Matchers -end -module RSpec::Mocks::Matchers::Matcher -end -module RSpec::Mocks::AnyInstance - def self.error_generator; end -end -class RSpec::Mocks::AnyInstance::Chain - def constrained_to_any_of?(*constraints); end - def expectation_fulfilled!; end - def initialize(recorder, *args, &block); end - def last_message; end - def matches_args?(*args); end - def messages; end - def negated?; end - def never; end - def playback!(instance); end - def record(rspec_method_name, *args, &block); end - def with(*args, &block); end - include RSpec::Mocks::AnyInstance::Chain::Customizations -end -module RSpec::Mocks::AnyInstance::Chain::Customizations - def and_call_original(*args, &block); end - def and_raise(*args, &block); end - def and_return(*args, &block); end - def and_throw(*args, &block); end - def and_wrap_original(*args, &block); end - def and_yield(*args, &block); end - def at_least(*args, &block); end - def at_most(*args, &block); end - def exactly(*args, &block); end - def never(*args, &block); end - def once(*args, &block); end - def self.record(method_name); end - def thrice(*args, &block); end - def time(*args, &block); end - def times(*args, &block); end - def twice(*args, &block); end - def with(*args, &block); end -end -class RSpec::Mocks::AnyInstance::ErrorGenerator < RSpec::Mocks::ErrorGenerator - def raise_does_not_implement_error(klass, method_name); end - def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end - def raise_not_supported_with_prepend_error(method_name, problem_mod); end - def raise_second_instance_received_message_error(unfulfilled_expectations); end -end -class RSpec::Mocks::AnyInstance::StubChain < RSpec::Mocks::AnyInstance::Chain - def create_message_expectation_on(instance); end - def expectation_fulfilled?; end - def invocation_order; end - def verify_invocation_order(rspec_method_name, *_args, &_block); end -end -class RSpec::Mocks::AnyInstance::StubChainChain < RSpec::Mocks::AnyInstance::StubChain - def create_message_expectation_on(instance); end - def initialize(*args); end - def invocation_order; end -end -class RSpec::Mocks::AnyInstance::ExpectChainChain < RSpec::Mocks::AnyInstance::StubChain - def create_message_expectation_on(instance); end - def expectation_fulfilled?; end - def initialize(*args); end - def invocation_order; end - def playback!(instance); end -end -class RSpec::Mocks::AnyInstance::ExpectationChain < RSpec::Mocks::AnyInstance::Chain - def expectation_fulfilled?; end - def initialize(*args, &block); end - def verify_invocation_order(_rspec_method_name, *_args, &_block); end -end -class RSpec::Mocks::AnyInstance::PositiveExpectationChain < RSpec::Mocks::AnyInstance::ExpectationChain - def create_message_expectation_on(instance); end - def invocation_order; end -end -class RSpec::Mocks::AnyInstance::MessageChains - def [](method_name); end - def add(method_name, chain); end - def all_expectations_fulfilled?; end - def each_unfulfilled_expectation_matching(method_name, *args); end - def has_expectation?(method_name); end - def initialize; end - def playback!(instance, method_name); end - def raise_if_second_instance_to_receive_message(instance); end - def received_expected_message!(method_name); end - def remove_stub_chains_for!(method_name); end - def unfulfilled_expectations; end -end -class RSpec::Mocks::AnyInstance::Recorder - def allow_no_prepended_module_definition_of(method_name); end - def already_observing?(method_name); end - def ancestor_is_an_observer?(method_name); end - def backup_method!(method_name); end - def build_alias_method_name(method_name); end - def expect_chain(*method_names_and_optional_return_values, &block); end - def initialize(klass); end - def instance_that_received(method_name); end - def klass; end - def mark_invoked!(method_name); end - def message_chains; end - def normalize_chain(*args); end - def notify_received_message(_object, message, args, _blk); end - def observe!(method_name); end - def playback!(instance, method_name); end - def public_protected_or_private_method_defined?(method_name); end - def received_expected_message!(method_name); end - def remove_dummy_method!(method_name); end - def restore_method!(method_name); end - def restore_original_method!(method_name); end - def should_not_receive(method_name, &block); end - def should_receive(method_name, &block); end - def stop_all_observation!; end - def stop_observing!(method_name); end - def stub(method_name, &block); end - def stub_chain(*method_names_and_optional_return_values, &block); end - def stubs; end - def super_class_observers_for(method_name); end - def super_class_observing?(method_name); end - def unstub(method_name); end - def verify; end -end -class RSpec::Mocks::AnyInstance::Proxy - def expect_chain(*chain, &block); end - def initialize(recorder, target_proxies); end - def klass; end - def perform_proxying(method_name, args, block, &target_proxy_block); end - def should_not_receive(method_name, &block); end - def should_receive(method_name, &block); end - def stub(method_name_or_method_map, &block); end - def stub_chain(*chain, &block); end - def unstub(method_name); end -end -class RSpec::Mocks::AnyInstance::FluentInterfaceProxy - def initialize(targets); end - def method_missing(*args, &block); end - def respond_to_missing?(method_name, include_private = nil); end -end -class RSpec::Mocks::MessageChain - def block; end - def chain; end - def chain_on(object, *chain, &block); end - def find_matching_expectation; end - def find_matching_stub; end - def format_chain(*chain, &blk); end - def initialize(object, *chain, &blk); end - def object; end - def setup_chain; end -end -class RSpec::Mocks::ExpectChain < RSpec::Mocks::MessageChain - def expectation(object, message, &return_block); end - def self.expect_chain_on(object, *chain, &blk); end -end -class RSpec::Mocks::StubChain < RSpec::Mocks::MessageChain - def expectation(object, message, &return_block); end - def self.stub_chain_on(object, *chain, &blk); end -end -class RSpec::Mocks::MarshalExtension - def self.patch!; end - def self.unpatch!; end -end -class RSpec::Mocks::Matchers::HaveReceived - def apply_constraints_to(expectation); end - def at_least(*args); end - def at_most(*args); end - def capture_failure_message; end - def count_constraint; end - def description; end - def disallow(type, reason = nil); end - def does_not_match?(subject); end - def ensure_count_unconstrained; end - def exactly(*args); end - def expect; end - def expected_messages_received_in_order?; end - def failure_message; end - def failure_message_when_negated; end - def initialize(method_name, &block); end - def matches?(subject, &block); end - def mock_proxy; end - def name; end - def notify_failure_message; end - def once(*args); end - def ordered(*args); end - def setup_allowance(_subject, &_block); end - def setup_any_instance_allowance(_subject, &_block); end - def setup_any_instance_expectation(_subject, &_block); end - def setup_any_instance_negative_expectation(_subject, &_block); end - def setup_expectation(subject, &block); end - def setup_negative_expectation(subject, &block); end - def thrice(*args); end - def time(*args); end - def times(*args); end - def twice(*args); end - def with(*args); end - include RSpec::Mocks::Matchers::Matcher -end -class RSpec::Mocks::Matchers::ExpectationCustomization - def block; end - def block=(arg0); end - def initialize(method_name, args, block); end - def playback_onto(expectation); end -end -class RSpec::Mocks::Matchers::Receive - def and_call_original(*args, &block); end - def and_invoke(*args, &block); end - def and_raise(*args, &block); end - def and_return(*args, &block); end - def and_throw(*args, &block); end - def and_wrap_original(*args, &block); end - def and_yield(*args, &block); end - def at_least(*args, &block); end - def at_most(*args, &block); end - def describable; end - def description; end - def does_not_match?(subject, &block); end - def exactly(*args, &block); end - def initialize(message, block); end - def matches?(subject, &block); end - def move_block_to_last_customization(block); end - def name; end - def never(*args, &block); end - def once(*args, &block); end - def ordered(*args, &block); end - def setup_allowance(subject, &block); end - def setup_any_instance_allowance(subject, &block); end - def setup_any_instance_expectation(subject, &block); end - def setup_any_instance_method_substitute(subject, method, block); end - def setup_any_instance_negative_expectation(subject, &block); end - def setup_expectation(subject, &block); end - def setup_method_substitute(host, method, block, *args); end - def setup_mock_proxy_method_substitute(subject, method, block); end - def setup_negative_expectation(subject, &block); end - def thrice(*args, &block); end - def time(*args, &block); end - def times(*args, &block); end - def twice(*args, &block); end - def warn_if_any_instance(expression, subject); end - def with(*args, &block); end - include RSpec::Mocks::Matchers::Matcher -end -class RSpec::Mocks::Matchers::Receive::DefaultDescribable - def description_for(verb); end - def initialize(message); end -end -class RSpec::Mocks::Matchers::ReceiveMessageChain - def and_call_original(*args, &block); end - def and_invoke(*args, &block); end - def and_raise(*args, &block); end - def and_return(*args, &block); end - def and_throw(*args, &block); end - def and_yield(*args, &block); end - def description; end - def does_not_match?(*_args); end - def formatted_chain; end - def initialize(chain, &block); end - def matches?(subject, &block); end - def name; end - def replay_customizations(chain); end - def setup_allowance(subject, &block); end - def setup_any_instance_allowance(subject, &block); end - def setup_any_instance_expectation(subject, &block); end - def setup_expectation(subject, &block); end - def setup_negative_expectation(*_args); end - def with(*args, &block); end - include RSpec::Mocks::Matchers::Matcher -end -class RSpec::Mocks::Matchers::ReceiveMessages - def any_instance_of(subject); end - def description; end - def does_not_match?(_subject); end - def each_message_on(host); end - def initialize(message_return_value_hash); end - def matches?(subject); end - def name; end - def proxy_on(subject); end - def setup_allowance(subject); end - def setup_any_instance_allowance(subject); end - def setup_any_instance_expectation(subject); end - def setup_expectation(subject); end - def setup_negative_expectation(_subject); end - def warn_about_block; end - include RSpec::Mocks::Matchers::Matcher -end diff --git a/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi b/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi new file mode 100644 index 00000000..5e2cd7f6 --- /dev/null +++ b/sorbet/rbi/gems/rspec-mocks@3.11.1.rbi @@ -0,0 +1,5387 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rspec-mocks` gem. +# Please instead update this file by running `bin/tapioca gem rspec-mocks`. + +# Share the top-level RSpec namespace, because we are a core supported +# extension. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:1 +module RSpec + class << self + # Used to ensure examples get reloaded between multiple runs in the same + # process and ensures user configuration is persisted. + # + # Users must invoke this if they want to clear all examples but preserve + # current configuration when they use the runner multiple times within the + # same process. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:70 + def clear_examples; end + + # Returns the global [Configuration](RSpec/Core/Configuration) object. While + # you _can_ use this method to access the configuration, the more common + # convention is to use [RSpec.configure](RSpec#configure-class_method). + # + # @example + # RSpec.configuration.drb_port = 1234 + # @see RSpec.configure + # @see Core::Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:85 + def configuration; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def configuration=(_arg0); end + + # Yields the global configuration to a block. + # + # @example + # RSpec.configure do |config| + # config.add_formatter 'documentation' + # end + # @see Core::Configuration + # @yield [Configuration] global configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:97 + def configure; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:194 + def const_missing(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def context(*args, &example_group_block); end + + # The example being executed. + # + # The primary audience for this method is library authors who need access + # to the example currently being executed and also want to support all + # versions of RSpec 2 and 3. + # + # @example + # + # RSpec.configure do |c| + # # context.example is deprecated, but RSpec.current_example is not + # # available until RSpec 3.0. + # fetch_current_example = RSpec.respond_to?(:current_example) ? + # proc { RSpec.current_example } : proc { |context| context.example } + # + # c.before(:example) do + # example = fetch_current_example.call(self) + # + # # ... + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:122 + def current_example; end + + # Set the current example being executed. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:128 + def current_example=(example); end + + # Get the current RSpec execution scope + # + # Returns (in order of lifecycle): + # * `:suite` as an initial value, this is outside of the test lifecycle. + # * `:before_suite_hook` during `before(:suite)` hooks. + # * `:before_context_hook` during `before(:context)` hooks. + # * `:before_example_hook` during `before(:example)` hooks and `around(:example)` before `example.run`. + # * `:example` within the example run. + # * `:after_example_hook` during `after(:example)` hooks and `around(:example)` after `example.run`. + # * `:after_context_hook` during `after(:context)` hooks. + # * `:after_suite_hook` during `after(:suite)` hooks. + # * `:suite` as a final value, again this is outside of the test lifecycle. + # + # Reminder, `:context` hooks have `:all` alias and `:example` hooks have `:each` alias. + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:154 + def current_scope; end + + # Set the current scope rspec is executing in + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:134 + def current_scope=(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def example_group(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fdescribe(*args, &example_group_block); end + + # Used to ensure examples get reloaded and user configuration gets reset to + # defaults between multiple runs in the same process. + # + # Users must invoke this if they want to have the configuration reset when + # they use the runner multiple times within the same process. Users must deal + # themselves with re-configuration of RSpec before run. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:58 + def reset; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_context(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples_for(name, *args, &block); end + + # Internal container for global non-configuration data. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:160 + def world; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def world=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xdescribe(*args, &example_group_block); end + end +end + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core.rb:187 +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +# Contains top-level utility methods. While this contains a few +# public methods, these are not generally meant to be called from +# a test or example. They exist primarily for integration with +# test frameworks (such as rspec-core). +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:2 +module RSpec::Mocks + class << self + # Adds an allowance (stub) on `subject` + # + # @example Defines the implementation of `foo` on `bar`, using the passed block + # x = 0 + # RSpec::Mocks.allow_message(bar, :foo) { x += 1 } + # @param subject the subject to which the message will be added + # @param message a symbol, representing the message that will be + # added. + # @param opts a hash of options, :expected_from is used to set the + # original call site + # @yield an optional implementation for the allowance + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:69 + def allow_message(subject, message, opts = T.unsafe(nil), &block); end + + # Mocks specific configuration, as distinct from `RSpec.configuration` + # which is core RSpec configuration. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:206 + def configuration; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:365 + def error_generator; end + + # Sets a message expectation on `subject`. + # + # @example Expect the message `foo` to receive `bar`, then call it + # RSpec::Mocks.expect_message(bar, :foo) + # bar.foo + # @param subject the subject on which the message will be expected + # @param message a symbol, representing the message that will be + # expected. + # @param opts a hash of options, :expected_from is used to set the + # original call site + # @yield an optional implementation for the expectation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:84 + def expect_message(subject, message, opts = T.unsafe(nil), &block); end + + # Performs per-test/example setup. This should be called before + # an test or example begins. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:38 + def setup; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:106 + def space; end + + # Cleans up all test double state (including any methods that were + # redefined on partial doubles). This _must_ be called after + # each example, even if an error was raised during the example. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:51 + def teardown; end + + # Verifies any message expectations that were set during the + # test or example. This should be called at the end of an example. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:44 + def verify; end + + # Call the passed block and verify mocks after it has executed. This allows + # mock usage in arbitrary places, such as a `before(:all)` hook. + # + # @return [Object] the return value from the block + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:92 + def with_temporary_scope; end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:92 +class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:93 + def expression; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:29 + def not_to(matcher, *_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:6 + def to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:29 + def to_not(matcher, *_args); end +end + +# Handles the implementation of an `and_invoke` implementation. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:739 +class RSpec::Mocks::AndInvokeImplementation + # @return [AndInvokeImplementation] a new instance of AndInvokeImplementation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:740 + def initialize(procs_to_invoke); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:744 + def call(*args, &block); end +end + +# Handles the implementation of an `and_return` implementation. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:723 +class RSpec::Mocks::AndReturnImplementation + # @return [AndReturnImplementation] a new instance of AndReturnImplementation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:724 + def initialize(values_to_return); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:728 + def call(*_args_to_ignore, &_block); end +end + +# Represents an `and_call_original` implementation. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:781 +class RSpec::Mocks::AndWrapOriginalImplementation + # @return [AndWrapOriginalImplementation] a new instance of AndWrapOriginalImplementation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:782 + def initialize(method, block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:809 + def call(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:789 + def initial_action=(_value); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:805 + def inner_action; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:793 + def inner_action=(_value); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:801 + def present?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:797 + def terminal_action=(_value); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:816 + def cannot_modify_further_error; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:787 +class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError; end + +# Handles the implementation of an `and_yield` declaration. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:696 +class RSpec::Mocks::AndYieldImplementation + # @return [AndYieldImplementation] a new instance of AndYieldImplementation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:697 + def initialize(args_to_yield, eval_context, error_generator); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:703 + def call(*_args_to_ignore, &block); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:4 +module RSpec::Mocks::AnyInstance + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:26 + def error_generator; end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:6 +class RSpec::Mocks::AnyInstance::Chain + include ::RSpec::Mocks::AnyInstance::Chain::Customizations + + # @return [Chain] a new instance of Chain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:7 + def initialize(recorder, *args, &block); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:61 + def constrained_to_any_of?(*constraints); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:75 + def expectation_fulfilled!; end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:70 + def matches_args?(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:79 + def never; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:53 + def playback!(instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:84 + def with(*args, &block); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:99 + def last_message; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:95 + def messages; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:91 + def negated?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:103 + def record(rspec_method_name, *args, &block); end +end + +# Provides convenience methods for recording customizations on message +# expectations. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:18 +module RSpec::Mocks::AnyInstance::Chain::Customizations + # Records the `and_call_original` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_call_original + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_call_original(*args, &block); end + + # Records the `and_raise` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_raise + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_raise(*args, &block); end + + # Records the `and_return` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_return + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_return(*args, &block); end + + # Records the `and_throw` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_throw + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_throw(*args, &block); end + + # Records the `and_wrap_original` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_wrap_original + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_wrap_original(*args, &block); end + + # Records the `and_yield` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#and_yield + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def and_yield(*args, &block); end + + # Records the `at_least` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#at_least + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def at_least(*args, &block); end + + # Records the `at_most` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#at_most + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def at_most(*args, &block); end + + # Records the `exactly` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#exactly + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def exactly(*args, &block); end + + # Records the `never` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#never + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def never(*args, &block); end + + # Records the `once` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#once + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def once(*args, &block); end + + # Records the `thrice` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#thrice + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def thrice(*args, &block); end + + # Records the `time` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#time + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def time(*args, &block); end + + # Records the `times` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#times + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def times(*args, &block); end + + # Records the `twice` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#twice + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def twice(*args, &block); end + + # Records the `with` message for playback against an instance that + # invokes a method stubbed or mocked using `any_instance`. + # + # @see RSpec::Mocks::MessageExpectation#with + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:27 + def with(*args, &block); end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/chain.rb:26 + def record(method_name); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:5 +class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:11 + def raise_does_not_implement_error(klass, method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:15 + def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:20 + def raise_not_supported_with_prepend_error(method_name, problem_mod); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/error_generator.rb:6 + def raise_second_instance_received_message_error(unfulfilled_expectations); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:5 +class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain + # @return [ExpectChainChain] a new instance of ExpectChainChain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:6 + def initialize(*args); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:11 + def expectation_fulfilled?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:15 + def playback!(instance); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:21 + def create_message_expectation_on(instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expect_chain_chain.rb:25 + def invocation_order; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:5 +class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain + # @return [ExpectationChain] a new instance of ExpectationChain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:10 + def initialize(*args, &block); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:6 + def expectation_fulfilled?; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:17 + def verify_invocation_order(_rspec_method_name, *_args, &_block); end +end + +# Delegates messages to each of the given targets in order to +# provide the fluent interface that is available off of message +# expectations when dealing with `any_instance`. +# +# `targets` will typically contain 1 of the `AnyInstance::Recorder` +# return values and N `MessageExpectation` instances (one per instance +# of the `any_instance` klass). +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:94 +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy + # @return [FluentInterfaceProxy] a new instance of FluentInterfaceProxy + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:95 + def initialize(targets); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:109 + def method_missing(*args, &block); end + + private + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:100 + def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:5 +class RSpec::Mocks::AnyInstance::MessageChains + # @return [MessageChains] a new instance of MessageChains + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:6 + def initialize; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:11 + def [](method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:16 + def add(method_name, chain); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:43 + def all_expectations_fulfilled?; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:36 + def each_unfulfilled_expectation_matching(method_name, *args); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:29 + def has_expectation?(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:64 + def playback!(instance, method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:57 + def received_expected_message!(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:22 + def remove_stub_chains_for!(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:50 + def unfulfilled_expectations; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/message_chains.rb:73 + def raise_if_second_instance_to_receive_message(instance); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:22 +class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:25 + def create_message_expectation_on(instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:44 + def invocation_order; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/expectation_chain.rb:38 +RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash) + +# The `AnyInstance::Recorder` is responsible for redefining the klass's +# instance method in order to add any stubs/expectations the first time +# the method is called. It's not capable of updating a stub on an instance +# that's already been previously stubbed (either directly, or via +# `any_instance`). +# +# This proxy sits in front of the recorder and delegates both to it +# and to the `RSpec::Mocks::Proxy` for each already mocked or stubbed +# instance of the class, in order to propogates changes to the instances. +# +# Note that unlike `RSpec::Mocks::Proxy`, this proxy class is stateless +# and is not persisted in `RSpec::Mocks.space`. +# +# Proxying for the message expectation fluent interface (typically chained +# off of the return value of one of these methods) is provided by the +# `FluentInterfaceProxy` class below. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:21 +class RSpec::Mocks::AnyInstance::Proxy + # @return [Proxy] a new instance of Proxy + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:22 + def initialize(recorder, target_proxies); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:55 + def expect_chain(*chain, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:27 + def klass; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:71 + def should_not_receive(method_name, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:61 + def should_receive(method_name, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:31 + def stub(method_name_or_method_map, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:49 + def stub_chain(*chain, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:43 + def unstub(method_name); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/proxy.rb:79 + def perform_proxying(method_name, args, block, &target_proxy_block); end +end + +# Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`, +# which records stubs and message expectations for later playback on +# instances of `TheClass`. +# +# Further constraints are stored in instances of [Chain](Chain). +# +# @see AnyInstance +# @see Chain +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:12 +class RSpec::Mocks::AnyInstance::Recorder + # @return [Recorder] a new instance of Recorder + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:16 + def initialize(klass); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:127 + def already_observing?(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:122 + def build_alias_method_name(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:53 + def expect_chain(*method_names_and_optional_return_values, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:117 + def instance_that_received(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:14 + def klass; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:14 + def message_chains; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:132 + def notify_received_message(_object, message, args, _blk); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:109 + def playback!(instance, method_name); end + + # The opposite of `should_receive` + # + # @see Methods#should_not_receive + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:75 + def should_not_receive(method_name, &block); end + + # Initializes the recording a message expectation to be played back + # against any instance of this object that invokes the submitted + # method. + # + # @see Methods#should_receive + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:66 + def should_receive(method_name, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:104 + def stop_all_observation!; end + + # Initializes the recording a stub to be played back against any + # instance of this object that invokes the submitted method. + # + # @see Methods#stub + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:35 + def stub(method_name, &block); end + + # Initializes the recording a stub chain to be played back against any + # instance of this object that invokes the method matching the first + # argument. + # + # @see Methods#stub_chain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:45 + def stub_chain(*method_names_and_optional_return_values, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:14 + def stubs; end + + # Removes any previously recorded stubs, stub_chains or message + # expectations that use `method_name`. + # + # @see Methods#unstub + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:83 + def unstub(method_name); end + + # Used internally to verify that message expectations have been + # fulfilled. + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:96 + def verify; end + + protected + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:148 + def stop_observing!(method_name); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:280 + def allow_no_prepended_module_definition_of(method_name); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:159 + def ancestor_is_an_observer?(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:233 + def backup_method!(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:267 + def mark_invoked!(method_name); end + + # @yield [args.first, args] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:176 + def normalize_chain(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:247 + def observe!(method_name); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:243 + def public_protected_or_private_method_defined?(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:181 + def received_expected_message!(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:227 + def remove_dummy_method!(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:187 + def restore_method!(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:195 + def restore_original_method!(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:168 + def super_class_observers_for(method_name); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/recorder.rb:172 + def super_class_observing?(method_name); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:6 +class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:7 + def expectation_fulfilled?; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:13 + def create_message_expectation_on(instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:40 + def invocation_order; end + + # @raise [NoMethodError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:44 + def verify_invocation_order(rspec_method_name, *_args, &_block); end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:38 +RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash) + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain.rb:28 +RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain_chain.rb:5 +class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain + # @return [StubChainChain] a new instance of StubChainChain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain_chain.rb:6 + def initialize(*args); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain_chain.rb:13 + def create_message_expectation_on(instance); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/any_instance/stub_chain_chain.rb:17 + def invocation_order; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:103 +class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:104 + def expression; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:29 + def not_to(matcher, *_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:6 + def to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:29 + def to_not(matcher, *_args); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:114 +class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:115 + def expression; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:16 + def not_to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:6 + def to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:16 + def to_not(matcher, &block); end +end + +# Wrapper for matching arguments against a list of expected values. Used by +# the `with` method on a `MessageExpectation`: +# +# expect(object).to receive(:message).with(:a, 'b', 3) +# object.message(:a, 'b', 3) +# +# Values passed to `with` can be literal values or argument matchers that +# match against the real objects .e.g. +# +# expect(object).to receive(:message).with(hash_including(:a => 'b')) +# +# Can also be used directly to match the contents of any `Array`. This +# enables 3rd party mocking libs to take advantage of rspec's argument +# matching without using the rest of rspec-mocks. +# +# require 'rspec/mocks/argument_list_matcher' +# include RSpec::Mocks::ArgumentMatchers +# +# arg_list_matcher = RSpec::Mocks::ArgumentListMatcher.new(123, hash_including(:a => 'b')) +# arg_list_matcher.args_match?(123, :a => 'b') +# +# This class is immutable. +# +# @see ArgumentMatchers +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:33 +class RSpec::Mocks::ArgumentListMatcher + # Initializes an `ArgumentListMatcher` with a collection of literal + # values and/or argument matchers. + # + # @api public + # @param expected_args [Array] a list of expected literals and/or argument matchers + # @return [ArgumentListMatcher] a new instance of ArgumentListMatcher + # @see ArgumentMatchers + # @see #args_match? + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:45 + def initialize(*expected_args); end + + # Matches each element in the `expected_args` against the element in the same + # position of the arguments passed to `new`. + # + # @api public + # @param actual_args [Array] + # @return [Boolean] + # @see #initialize + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:58 + def args_match?(*actual_args); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:35 + def expected_args; end + + # Resolves abstract arg placeholders like `no_args` and `any_args` into + # a more concrete arg list based on the provided `actual_args`. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:79 + def resolve_expected_args_based_on(actual_args); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:98 + def ensure_expected_args_valid!; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:90 + def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end +end + +# Value that will match all argument lists. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_list_matcher.rb:112 +RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher) + +# ArgumentMatchers are placeholders that you can include in message +# expectations to match arguments against a broader check than simple +# equality. +# +# With the exception of `any_args` and `no_args`, they all match against +# the arg in same position in the argument list. +# +# @see ArgumentListMatcher +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:16 +module RSpec::Mocks::ArgumentMatchers + # Matches if `arg.kind_of?(klass)` + # + # @example + # expect(object).to receive(:message).with(kind_of(Thing)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:111 + def a_kind_of(klass); end + + # Matches if `arg.instance_of?(klass)` + # + # @example + # expect(object).to receive(:message).with(instance_of(Thing)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:101 + def an_instance_of(klass); end + + # Acts like an arg splat, matching any number of args at any point in an arg list. + # + # @example + # expect(object).to receive(:message).with(1, 2, any_args) + # + # # matches any of these: + # object.message(1, 2) + # object.message(1, 2, 3) + # object.message(1, 2, 3, 4) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:26 + def any_args; end + + # Matches any argument at all. + # + # @example + # expect(object).to receive(:message).with(anything) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:34 + def anything; end + + # Matches an array that includes the specified items at least once. + # Ignores duplicates and additional values + # + # @example + # expect(object).to receive(:message).with(array_including(1,2,3)) + # expect(object).to receive(:message).with(array_including([1,2,3])) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:80 + def array_including(*args); end + + # Matches a boolean value. + # + # @example + # expect(object).to receive(:message).with(boolean()) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:59 + def boolean; end + + # Matches if the actual argument responds to the specified messages. + # + # @example + # expect(object).to receive(:message).with(duck_type(:hello)) + # expect(object).to receive(:message).with(duck_type(:hello, :goodbye)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:51 + def duck_type(*args); end + + # Matches a hash that doesn't include the specified key(s) or key/value. + # + # @example + # expect(object).to receive(:message).with(hash_excluding(:key => val)) + # expect(object).to receive(:message).with(hash_excluding(:key)) + # expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:91 + def hash_excluding(*args); end + + # Matches a hash that includes the specified key(s) or key/value pairs. + # Ignores any additional keys. + # + # @example + # expect(object).to receive(:message).with(hash_including(:key => val)) + # expect(object).to receive(:message).with(hash_including(:key)) + # expect(object).to receive(:message).with(hash_including(:key, :key2 => val2)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:70 + def hash_including(*args); end + + # Matches a hash that doesn't include the specified key(s) or key/value. + # + # @example + # expect(object).to receive(:message).with(hash_excluding(:key => val)) + # expect(object).to receive(:message).with(hash_excluding(:key)) + # expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:91 + def hash_not_including(*args); end + + # Matches if `arg.instance_of?(klass)` + # + # @example + # expect(object).to receive(:message).with(instance_of(Thing)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:101 + def instance_of(klass); end + + # Matches if `arg.kind_of?(klass)` + # + # @example + # expect(object).to receive(:message).with(kind_of(Thing)) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:111 + def kind_of(klass); end + + # Matches no arguments. + # + # @example + # expect(object).to receive(:message).with(no_args) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:42 + def no_args; end + + class << self + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:118 + def anythingize_lonely_keys(*args); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:149 +class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:150 + def ===(_other); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:154 + def description; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:137 +RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher) + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:142 +class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:143 + def description; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:137 +RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher) + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:232 +class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher + # @return [ArrayIncludingMatcher] a new instance of ArrayIncludingMatcher + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:233 + def initialize(expected); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:237 + def ===(actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:248 + def description; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:254 + def formatted_expected_values; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:178 +class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + # @return [BaseHashMatcher] a new instance of BaseHashMatcher + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:179 + def initialize(expected); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:183 + def ===(predicate, actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:191 + def description(name); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:197 + def formatted_expected_hash; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:167 +class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:168 + def ===(value); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:172 + def description; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:137 +RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher) + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:262 +class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher + # @return [DuckTypeMatcher] a new instance of DuckTypeMatcher + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:263 + def initialize(*methods_to_respond_to); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:267 + def ===(value); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:271 + def description; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:221 +class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:222 + def ===(actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:226 + def description; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:210 +class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:211 + def ===(actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:215 + def description; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:277 +class RSpec::Mocks::ArgumentMatchers::InstanceOf + # @return [InstanceOf] a new instance of InstanceOf + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:278 + def initialize(klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:282 + def ===(actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:286 + def description; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:292 +class RSpec::Mocks::ArgumentMatchers::KindOf + # @return [KindOf] a new instance of KindOf + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:293 + def initialize(klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:297 + def ===(actual); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:301 + def description; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:160 +class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:161 + def description; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:137 +RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher) + +# Intended to be subclassed by stateless, immutable argument matchers. +# Provides a `<klass name>::INSTANCE` constant for accessing a global +# singleton instance of the matcher. There is no need to construct +# multiple instance since there is no state. It also facilities the +# special case logic we need for some of these matchers, by making it +# easy to do comparisons like: `[klass::INSTANCE] == args` rather than +# `args.count == 1 && klass === args.first`. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:133 +class RSpec::Mocks::ArgumentMatchers::SingletonMatcher + class << self + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/argument_matchers.rb:136 + def inherited(subklass); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:7 +class RSpec::Mocks::CallbackInvocationStrategy + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:8 + def call(doubled_module); end +end + +# Raised for situations that RSpec cannot support due to mutations made +# externally on arguments that RSpec is holding onto to use for later +# comparisons. +# +# @deprecated We no longer raise this error but the constant remains until +# RSpec 4 for SemVer reasons. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:26 +class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError; end + +# When a class's `.new` method is stubbed, we want to use the method +# signature from `#initialize` because `.new`'s signature is a generic +# `def new(*args)` and it simply delegates to `#initialize` and forwards +# all args...so the method with the actually used signature is `#initialize`. +# +# This method reference implementation handles that specific case. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:184 +class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:195 + def with_signature; end + + class << self + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:185 + def applies_to?(method_name); end + end +end + +# Effectively the same as an ObjectVerifyingDouble (since a class is a type +# of object), except with Module in the inheritance chain so that +# transferring nested constants to work. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:117 +class RSpec::Mocks::ClassVerifyingDouble < ::Module + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble + include ::RSpec::Mocks::ObjectVerifyingDoubleMethods +end + +# Provides configuration options for rspec-mocks. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:4 +class RSpec::Mocks::Configuration + # @return [Configuration] a new instance of Configuration + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:5 + def initialize; end + + # Adds `stub` and `should_receive` to the given + # modules or classes. This is usually only necessary + # if you application uses some proxy classes that + # "strip themselves down" to a bare minimum set of + # methods and remove `stub` and `should_receive` in + # the process. + # + # @example + # RSpec.configure do |rspec| + # rspec.mock_with :rspec do |mocks| + # mocks.add_stub_and_should_receive_to Delegator + # end + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:62 + def add_stub_and_should_receive_to(*modules); end + + # Sets whether RSpec will warn, ignore, or fail a test when + # expectations are set on nil. + # By default, when this flag is not set, warning messages are issued when + # expectations are set on nil. This is to prevent false-positives and to + # catch potential bugs early on. + # When set to `true`, warning messages are suppressed. + # When set to `false`, it will raise an error. + # + # @example + # RSpec.configure do |config| + # config.mock_with :rspec do |mocks| + # mocks.allow_message_expectations_on_nil = false + # end + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:29 + def allow_message_expectations_on_nil; end + + # Sets whether RSpec will warn, ignore, or fail a test when + # expectations are set on nil. + # By default, when this flag is not set, warning messages are issued when + # expectations are set on nil. This is to prevent false-positives and to + # catch potential bugs early on. + # When set to `true`, warning messages are suppressed. + # When set to `false`, it will raise an error. + # + # @example + # RSpec.configure do |config| + # config.mock_with :rspec do |mocks| + # mocks.allow_message_expectations_on_nil = false + # end + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:29 + def allow_message_expectations_on_nil=(_arg0); end + + # Provides a way to perform customisations when verifying doubles. + # + # @example + # RSpec::Mocks.configuration.before_verifying_doubles do |ref| + # ref.some_method! + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:128 + def before_verifying_doubles(&block); end + + # Indicates whether or not diffs should be colored. + # Delegates to rspec-core's color option if rspec-core + # is loaded; otherwise you can set it here. + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:164 + def color?; end + + # Monkey-patch `Marshal.dump` to enable dumping of mocked or stubbed + # objects. By default this will not work since RSpec mocks works by + # adding singleton methods that cannot be serialized. This patch removes + # these singleton methods before serialization. Setting to falsey removes + # the patch. + # + # This method is idempotent. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:188 + def patch_marshal_to_support_partial_doubles=(val); end + + # Resets the configured syntax to the default. + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:198 + def reset_syntaxes_to_default; end + + # Returns an array with a list of syntaxes + # that are enabled. + # + # @example + # unless RSpec::Mocks.configuration.syntax.include?(:expect) + # raise "this RSpec extension gem requires the rspec-mocks `:expect` syntax" + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:104 + def syntax; end + + # Provides the ability to set either `expect`, + # `should` or both syntaxes. RSpec uses `expect` + # syntax by default. This is needed if you want to + # explicitly enable `should` syntax and/or explicitly + # disable `expect` syntax. + # + # end + # + # @example + # RSpec.configure do |rspec| + # rspec.mock_with :rspec do |mocks| + # mocks.syntax = [:expect, :should] + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:81 + def syntax=(*values); end + + # Used to track wether we are temporarily suppressing verifying partial + # doubles with `without_partial_double_verification { ... }` + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:161 + def temporarily_suppress_partial_double_verification; end + + # Used to track wether we are temporarily suppressing verifying partial + # doubles with `without_partial_double_verification { ... }` + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:161 + def temporarily_suppress_partial_double_verification=(_arg0); end + + # Sets the default for the `transfer_nested_constants` option when + # stubbing constants. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:145 + def transfer_nested_constants=(_arg0); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:139 + def transfer_nested_constants?; end + + # When this is set to true, an error will be raised when + # `instance_double` or `class_double` is given the name of an undefined + # constant. You probably only want to set this when running your entire + # test suite, with all production code loaded. Setting this for an + # isolated unit test will prevent you from being able to isolate it! + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:120 + def verify_doubled_constant_names=(_arg0); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:111 + def verify_doubled_constant_names?; end + + # When set to true, partial mocks will be verified the same as object + # doubles. Any stubs will have their arguments checked against the original + # method, and methods that do not exist cannot be stubbed. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:150 + def verify_partial_doubles=(val); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:154 + def verify_partial_doubles?; end + + # Returns an array of blocks to call when verifying doubles + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:135 + def verifying_double_callbacks; end + + # Provides a way to perform customisations when verifying doubles. + # + # @example + # RSpec::Mocks.configuration.before_verifying_doubles do |ref| + # ref.some_method! + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:128 + def when_declaring_verifying_double(&block); end + + # Sets whether or not RSpec will yield the receiving instance of a + # message to blocks that are used for any_instance stub implementations. + # When set, the first yielded argument will be the receiving instance. + # Defaults to `true`. + # + # @example + # RSpec.configure do |rspec| + # rspec.mock_with :rspec do |mocks| + # mocks.yield_receiver_to_any_instance_implementation_blocks = false + # end + # end + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:46 + def yield_receiver_to_any_instance_implementation_blocks=(_arg0); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/configuration.rb:31 + def yield_receiver_to_any_instance_implementation_blocks?; end +end + +# Provides information about constants that may (or may not) +# have been mutated by rspec-mocks. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:7 +class RSpec::Mocks::Constant + extend ::RSpec::Support::RecursiveConstMethods + + # @api private + # @return [Constant] a new instance of Constant + # @yield [_self] + # @yieldparam _self [RSpec::Mocks::Constant] the object that the method was called on + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:11 + def initialize(name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:29 + def hidden=(_arg0); end + + # @return [Boolean] Whether or not rspec-mocks has hidden + # this constant. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:51 + def hidden?; end + + # The default `to_s` isn't very useful, so a custom version is provided. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:62 + def inspect; end + + # @return [Boolean] Whether or not rspec-mocks has mutated + # (stubbed or hidden) this constant. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:39 + def mutated?; end + + # @return [String] The fully qualified name of the constant. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:21 + def name; end + + # @return [Object, nil] The original value (e.g. before it + # was mutated by rspec-mocks) of the constant, or + # nil if the constant was not previously defined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:26 + def original_value; end + + # @return [Object, nil] The original value (e.g. before it + # was mutated by rspec-mocks) of the constant, or + # nil if the constant was not previously defined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:26 + def original_value=(_arg0); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:29 + def previously_defined=(_arg0); end + + # @return [Boolean] Whether or not the constant was defined + # before the current example. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:33 + def previously_defined?; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:29 + def stubbed=(_arg0); end + + # @return [Boolean] Whether or not rspec-mocks has stubbed + # this constant. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:45 + def stubbed?; end + + # The default `to_s` isn't very useful, so a custom version is provided. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:62 + def to_s; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:29 + def valid_name=(_arg0); end + + # @return [Boolean] Whether or not the provided constant name + # is a valid Ruby constant name. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:57 + def valid_name?; end + + class << self + # Queries rspec-mocks to find out information about the named constant. + # + # @param name [String] the name of the constant + # @return [Constant] an object contaning information about the named + # constant. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:86 + def original(name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:68 + def unmutated(name); end + end +end + +# Provides a means to stub constants. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:93 +class RSpec::Mocks::ConstantMutator + extend ::RSpec::Support::RecursiveConstMethods + + class << self + # Hides a constant. + # + # @note It's recommended that you use `hide_const` in your + # examples. This is an alternate public API that is provided + # so you can hide constants in other contexts (e.g. helper + # classes). + # @param constant_name [String] The fully qualified name of the constant. + # The current constant scoping at the point of call is not considered. + # @see ExampleMethods#hide_const + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:131 + def hide(constant_name); end + + # Uses the mutator to mutate (stub or hide) a constant. Ensures that + # the mutator is correctly registered so it can be backed out at the end + # of the test. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:320 + def mutate(mutator); end + + # Used internally by the constant stubbing to raise a helpful + # error when a constant like "A::B::C" is stubbed and A::B is + # not a module (and thus, it's impossible to define "A::B::C" + # since only modules can have nested constants). + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:331 + def raise_on_invalid_const; end + + # Stubs a constant. + # + # @note It's recommended that you use `stub_const` in your + # examples. This is an alternate public API that is provided + # so you can stub constants in other contexts (e.g. helper + # classes). + # @option options + # @param constant_name [String] The fully qualified name of the constant. The current + # constant scoping at the point of call is not considered. + # @param value [Object] The value to make the constant refer to. When the + # example completes, the constant will be restored to its prior state. + # @param options [Hash] Stubbing options. + # @return [Object] the stubbed value of the constant + # @see ExampleMethods#stub_const + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:107 + def stub(constant_name, value, options = T.unsafe(nil)); end + end +end + +# Contains common functionality used by all of the constant mutators. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:139 +class RSpec::Mocks::ConstantMutator::BaseMutator + include ::RSpec::Support::RecursiveConstMethods + + # @return [BaseMutator] a new instance of BaseMutator + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:144 + def initialize(full_constant_name, mutated_value, transfer_nested_constants); end + + # Returns the value of attribute full_constant_name. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:142 + def full_constant_name; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:160 + def idempotently_reset; end + + # Returns the value of attribute original_value. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:142 + def original_value; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:153 + def to_constant; end +end + +# Hides a defined constant for the duration of an example. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:169 +class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:170 + def mutate; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:188 + def reset; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:178 + def to_constant; end +end + +# Replaces a defined constant for the duration of an example. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:197 +class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator + # @return [DefinedConstantReplacer] a new instance of DefinedConstantReplacer + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:198 + def initialize(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:203 + def mutate; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:223 + def reset; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:268 + def should_transfer_nested_constants?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:215 + def to_constant; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:232 + def transfer_nested_constants; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:238 + def verify_constants_to_transfer!; end +end + +# Sets an undefined constant for the duration of an example. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:278 +class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:279 + def mutate; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:299 + def reset; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:291 + def to_constant; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/mutate_const.rb:305 + def name_for(parent, name); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:104 +RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy) + +# An implementation of rspec-mocks' reference interface. +# Used when an object is passed to {ExampleMethods#object_double}, or +# an anonymous class or module is passed to {ExampleMethods#instance_double} +# or {ExampleMethods#class_double}. +# Represents a reference to that object. +# +# @see NamedObjectReference +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:56 +class RSpec::Mocks::DirectObjectReference + # @param object [Object] the object to which this refers + # @return [DirectObjectReference] a new instance of DirectObjectReference + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:58 + def initialize(object); end + + # Defined for interface parity with the other object reference + # implementations. Raises an `ArgumentError` to indicate that `as_stubbed_const` + # is invalid when passing an object argument to `object_double`. + # + # @raise [ArgumentError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:70 + def const_to_replace; end + + # Always returns true for an object as the class is defined. + # + # @return [true] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:85 + def defined?; end + + # @return [String] the object's description (via `#inspect`). + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:63 + def description; end + + # The target of the verifying double (the object itself). + # + # @return [Object] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:78 + def target; end + + # Yields if the reference target is loaded, providing a generic mechanism + # to optionally run a bit of code only when a reference's target is + # loaded. + # + # This specific implementation always yields because direct references + # are always loaded. + # + # @yield [Object] the target of this reference. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:97 + def when_loaded; end +end + +# A generic test double object. `double`, `instance_double` and friends +# return an instance of this. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:132 +class RSpec::Mocks::Double + include ::RSpec::Mocks::TestDouble +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:36 +class RSpec::Mocks::ErrorGenerator + # @return [ErrorGenerator] a new instance of ErrorGenerator + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:39 + def initialize(target = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:71 + def default_error_message(expectation, expected_args, actual_args); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:132 + def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:215 + def expectation_on_nil_message(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:222 + def intro(unwrapped = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:235 + def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:44 + def opts; end + + # Sets the attribute opts + # + # @param value the value to set the attribute opts to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:37 + def opts=(_arg0); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:203 + def raise_already_invoked_error(message, calling_customization); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:193 + def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:170 + def raise_double_negation_error(wrapped_expression); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:77 + def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:164 + def raise_expectation_on_mocked_method(method); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:211 + def raise_expectation_on_nil_error(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:158 + def raise_expectation_on_unstubbed_method(method); end + + # @private + # @raise [ExpiredTestDoubleError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:123 + def raise_expired_test_double_error; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:187 + def raise_have_received_disallowed(type, reason); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:118 + def raise_invalid_arguments_error(verifier); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:198 + def raise_method_not_stubbed_error(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:142 + def raise_missing_block_error(args_to_yield); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:59 + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + + # @private + # @raise [NoMethodError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:111 + def raise_non_public_error(method_name, visibility); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:152 + def raise_only_valid_on_a_partial_double(method); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:137 + def raise_out_of_order_error(message); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:67 + def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:54 + def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:49 + def raise_unexpected_message_error(message, args); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:87 + def raise_unimplemented_error(doubled_module, method_name, object); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:178 + def raise_verifying_double_not_defined_error(ref); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:147 + def raise_wrong_arity_error(args_to_yield, signature); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:307 + def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:335 + def arg_list(args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:345 + def count_message(count, expectation_count_type = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:281 + def diff_message(expected_args, actual_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:303 + def differ; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:268 + def error_message(expectation, args_for_multiple_calls); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:257 + def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:330 + def format_args(args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:339 + def format_received_args(args_for_multiple_calls); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:359 + def group_count(index, args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:355 + def grouped_args(args); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:299 + def list_of_exactly_one_string?(args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:326 + def notify(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:321 + def prepend_to_backtrace(exception, line); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:250 + def received_part_of_expectation_error(actual_received_count, args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:351 + def times(count); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:264 + def unexpected_arguments_message(expected_args_string, actual_args_string); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:291 + def unpack_string_args(formatted_expected_args, actual_args); end +end + +# Contains methods intended to be used from within code examples. +# Mix this in to your test context (such as a test framework base class) +# to use rspec-mocks with your test framework. If you're using rspec-core, +# it'll take care of doing this for you. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:9 +module RSpec::Mocks::ExampleMethods + include ::RSpec::Mocks::ArgumentMatchers + include ::RSpec::Mocks::ExampleMethods::ExpectHost + + # Used to wrap an object in preparation for stubbing a method + # on it. + # + # @example + # allow(dbl).to receive(:foo).with(5).and_return(:return_value) + # @note If you disable the `:expect` syntax this method will be undefined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:128 + def allow(target); end + + # Used to wrap a class in preparation for stubbing a method + # on instances of it. + # + # @example + # allow_any_instance_of(MyClass).to receive(:foo) + # @note This is only available when you have enabled the `expect` syntax. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:136 + def allow_any_instance_of(klass); end + + # Disables warning messages about expectations being set on nil. + # + # By default warning messages are issued when expectations are set on + # nil. This is to prevent false-positives and to catch potential bugs + # early on. + # + # @deprecated Use {RSpec::Mocks::Configuration#allow_message_expectations_on_nil} instead. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:201 + def allow_message_expectations_on_nil; end + + # Constructs a test double against a specific class. If the given class + # name has been loaded, only class methods defined on the class are + # allowed to be stubbed. In all other ways it behaves like a + # [double](double). + # + # @overload class_double + # @overload class_double + # @overload class_double + # @overload class_double + # @return ClassVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:79 + def class_double(doubled_class, *args); end + + # Constructs a test double that is optimized for use with `have_received` + # against a specific class. If the given class name has been loaded, + # only class methods defined on the class are allowed to be stubbed. + # With a normal double one has to stub methods in order to be able to spy + # them. An class_spy automatically spies on all class methods to which the + # class responds. + # + # @overload class_spy + # @overload class_spy + # @overload class_spy + # @overload class_spy + # @return ClassVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:191 + def class_spy(*args); end + + # Constructs an instance of [RSpec::Mocks::Double](RSpec::Mocks::Double) configured + # with an optional name, used for reporting in failure messages, and an optional + # hash of message/return-value pairs. + # + # @example + # book = double("book", :title => "The RSpec Book") + # book.title #=> "The RSpec Book" + # + # card = double("card", :suit => "Spades", :rank => "A") + # card.suit #=> "Spades" + # card.rank #=> "A" + # @overload double + # @overload double + # @overload double + # @overload double + # @return [Double] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:34 + def double(*args); end + + # Used to wrap a class in preparation for setting a mock expectation + # on instances of it. + # + # @example + # expect_any_instance_of(MyClass).to receive(:foo) + # @note If you disable the `:expect` syntax this method will be undefined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:132 + def expect_any_instance_of(klass); end + + # Verifies that the given object received the expected message during the + # course of the test. On a spy objects or as null object doubles this + # works for any method, on other objects the method must have + # been stubbed beforehand in order for messages to be verified. + # + # Stubbing and verifying messages received in this way implements the + # Test Spy pattern. + # + # @example + # invitation = double('invitation', accept: true) + # user.accept_invitation(invitation) + # expect(invitation).to have_received(:accept) + # + # # You can also use most message expectations: + # expect(invitation).to have_received(:accept).with(mailer).once + # @note `have_received(...).with(...)` is unable to work properly when + # passed arguments are mutated after the spy records the received message. + # @param method_name [Symbol] name of the method expected to have been + # called. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:281 + def have_received(method_name, &block); end + + # Hides the named constant with the given value. The constant will be + # undefined for the duration of the test. + # + # Like method stubs, the constant will be restored to its original value + # when the example completes. + # + # @example + # hide_const("MyClass") # => MyClass is now an undefined constant + # @param constant_name [String] The fully qualified name of the constant. + # The current constant scoping at the point of call is not considered. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:256 + def hide_const(constant_name); end + + # Constructs a test double against a specific class. If the given class + # name has been loaded, only instance methods defined on the class are + # allowed to be stubbed. In all other ways it behaves like a + # [double](double). + # + # @overload instance_double + # @overload instance_double + # @overload instance_double + # @overload instance_double + # @return InstanceVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:56 + def instance_double(doubled_class, *args); end + + # Constructs a test double that is optimized for use with `have_received` + # against a specific class. If the given class name has been loaded, only + # instance methods defined on the class are allowed to be stubbed. With + # a normal double one has to stub methods in order to be able to spy + # them. An instance_spy automatically spies on all instance methods to + # which the class responds. + # + # @overload instance_spy + # @overload instance_spy + # @overload instance_spy + # @overload instance_spy + # @return InstanceVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:144 + def instance_spy(*args); end + + # Constructs a test double against a specific object. Only the methods + # the object responds to are allowed to be stubbed. If a String argument + # is provided, it is assumed to reference a constant object which is used + # for verification. In all other ways it behaves like a [double](double). + # + # @overload object_double + # @overload object_double + # @overload object_double + # @overload object_double + # @return ObjectVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:102 + def object_double(object_or_name, *args); end + + # Constructs a test double that is optimized for use with `have_received` + # against a specific object. Only instance methods defined on the object + # are allowed to be stubbed. With a normal double one has to stub + # methods in order to be able to spy them. An object_spy automatically + # spies on all methods to which the object responds. + # + # @overload object_spy + # @overload object_spy + # @overload object_spy + # @overload object_spy + # @return ObjectVerifyingDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:167 + def object_spy(*args); end + + # Used to specify a message that you expect or allow an object + # to receive. The object returned by `receive` supports the same + # fluent interface that `should_receive` and `stub` have always + # supported, allowing you to constrain the arguments or number of + # times, and configure how the object should respond to the message. + # + # @example + # expect(obj).to receive(:hello).with("world").exactly(3).times + # @note If you disable the `:expect` syntax this method will be undefined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:114 + def receive(method_name, &block); end + + # stubs/mocks a chain of messages on an object or test double. + # + # ## Warning: + # + # Chains can be arbitrarily long, which makes it quite painless to + # violate the Law of Demeter in violent ways, so you should consider any + # use of `receive_message_chain` a code smell. Even though not all code smells + # indicate real problems (think fluent interfaces), `receive_message_chain` still + # results in brittle examples. For example, if you write + # `allow(foo).to receive_message_chain(:bar, :baz => 37)` in a spec and then the + # implementation calls `foo.baz.bar`, the stub will not work. + # + # @example + # allow(double).to receive_message_chain("foo.bar") { :baz } + # allow(double).to receive_message_chain(:foo, :bar => :baz) + # allow(double).to receive_message_chain(:foo, :bar) { :baz } + # + # # Given any of ^^ these three forms ^^: + # double.foo.bar # => :baz + # + # # Common use in Rails/ActiveRecord: + # allow(Article).to receive_message_chain("recent.published") { [Article.new] } + # @note If you disable the `:expect` syntax this method will be undefined. + # @overload receive_message_chain + # @overload receive_message_chain + # @overload receive_message_chain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:124 + def receive_message_chain(*messages, &block); end + + # Shorthand syntax used to setup message(s), and their return value(s), + # that you expect or allow an object to receive. The method takes a hash + # of messages and their respective return values. Unlike with `receive`, + # you cannot apply further customizations using a block or the fluent + # interface. + # + # @example + # allow(obj).to receive_messages(:speak => "Hello World") + # allow(obj).to receive_messages(:speak => "Hello", :meow => "Meow") + # @note If you disable the `:expect` syntax this method will be undefined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:118 + def receive_messages(message_return_value_hash); end + + # Constructs a test double that is optimized for use with + # `have_received`. With a normal double one has to stub methods in order + # to be able to spy them. A spy automatically spies on all methods. + # + # @overload spy + # @overload spy + # @overload spy + # @overload spy + # @return [Double] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:120 + def spy(*args); end + + # Stubs the named constant with the given value. + # Like method stubs, the constant will be restored + # to its original value (or lack of one, if it was + # undefined) when the example completes. + # + # @example + # stub_const("MyClass", Class.new) # => Replaces (or defines) MyClass with a new class object. + # stub_const("SomeModel::PER_PAGE", 5) # => Sets SomeModel::PER_PAGE to 5. + # + # class CardDeck + # SUITS = [:Spades, :Diamonds, :Clubs, :Hearts] + # NUM_CARDS = 52 + # end + # + # stub_const("CardDeck", Class.new) + # CardDeck::SUITS # => uninitialized constant error + # CardDeck::NUM_CARDS # => uninitialized constant error + # + # stub_const("CardDeck", Class.new, :transfer_nested_constants => true) + # CardDeck::SUITS # => our suits array + # CardDeck::NUM_CARDS # => 52 + # + # stub_const("CardDeck", Class.new, :transfer_nested_constants => [:SUITS]) + # CardDeck::SUITS # => our suits array + # CardDeck::NUM_CARDS # => uninitialized constant error + # @option options + # @param constant_name [String] The fully qualified name of the constant. The current + # constant scoping at the point of call is not considered. + # @param value [Object] The value to make the constant refer to. When the + # example completes, the constant will be restored to its prior state. + # @param options [Hash] Stubbing options. + # @return [Object] the stubbed value of the constant + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:241 + def stub_const(constant_name, value, options = T.unsafe(nil)); end + + # Turns off the verifying of partial doubles for the duration of the + # block, this is useful in situations where methods are defined at run + # time and you wish to define stubs for them but not turn off partial + # doubles for the entire run suite. (e.g. view specs in rspec-rails). + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:289 + def without_partial_double_verification; end + + class << self + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:423 + def declare_double(type, *args); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:408 + def declare_verifying_double(type, ref, *args); end + + # @private + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:401 + def extended(object); end + + # @private + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:392 + def included(klass); end + end +end + +# This module exists to host the `expect` method for cases where +# rspec-mocks is used w/o rspec-expectations. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/example_methods.rb:430 +module RSpec::Mocks::ExampleMethods::ExpectHost + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:142 + def expect(target); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:62 +class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:69 + def expectation(object, message, &return_block); end + + class << self + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:63 + def expect_chain_on(object, *chain, &blk); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:87 +class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase + include ::RSpec::Mocks::ExpectationTargetMethods +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:73 +module RSpec::Mocks::ExpectationTargetMethods + include ::RSpec::Mocks::TargetDelegationInstanceMethods + extend ::RSpec::Mocks::TargetDelegationClassMethods + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:81 + def expression; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:16 + def not_to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:6 + def to(matcher, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:16 + def to_not(matcher, &block); end +end + +# Raised when a test double is used after it has been torn +# down (typically at the end of an rspec-core example). +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:10 +class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:112 +RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String) + +# Represents a configured implementation. Takes into account +# any number of sub-implementations. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:758 +class RSpec::Mocks::Implementation + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:761 + def call(*args, &block); end + + # Returns the value of attribute initial_action. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def initial_action; end + + # Sets the attribute initial_action + # + # @param value the value to set the attribute initial_action to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def initial_action=(_arg0); end + + # Returns the value of attribute inner_action. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def inner_action; end + + # Sets the attribute inner_action + # + # @param value the value to set the attribute inner_action to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def inner_action=(_arg0); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:768 + def present?; end + + # Returns the value of attribute terminal_action. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def terminal_action; end + + # Sets the attribute terminal_action + # + # @param value the value to set the attribute terminal_action to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:759 + def terminal_action=(_arg0); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:774 + def actions; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:113 +class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:138 + def find_method(mod); end + + # Ideally, we'd use `respond_to?` for `method_implemented?` but we need a + # reference to an instance to do that and we don't have one. Note that + # we may get false negatives: if the method is implemented via + # `method_missing`, we'll return `false` even though it meets our + # definition of "implemented". However, it's the best we can do. + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:116 + def method_defined?(mod); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:116 + def method_implemented?(mod); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:143 + def visibility_from(mod); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:4 +class RSpec::Mocks::InstanceMethodStasher + # @return [InstanceMethodStasher] a new instance of InstanceMethodStasher + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:5 + def initialize(object, method); end + + # ruby 2.0.0-p247 and 2.0.0-p195 both have a bug that we can't work around :(. + # https://bugs.ruby-lang.org/issues/8686 + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:91 + def handle_restoration_failures; end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:49 + def method_is_stashed?; end + + # Returns the value of attribute original_method. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:14 + def original_method; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:61 + def restore; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:54 + def stash; end + + private + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:100 + def method_defined_directly_on_klass?; end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:105 + def method_defined_on_klass?(klass = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/instance_method_stasher.rb:109 + def method_owned_by_klass?; end +end + +# A mock providing a custom proxy that can verify the validity of any +# method stubs or expectations against the public instance methods of the +# given class. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:69 +class RSpec::Mocks::InstanceVerifyingDouble + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:73 + def __build_mock_proxy(order_group); end +end + +# Support for `patch_marshal_to_support_partial_doubles` configuration. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/marshal_extension.rb:6 +class RSpec::Mocks::MarshalExtension + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/marshal_extension.rb:7 + def patch!; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/marshal_extension.rb:27 + def unpatch!; end + end +end + +# Namespace for mock-related matchers. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:122 +module RSpec::Mocks::Matchers; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/expectation_customization.rb:5 +class RSpec::Mocks::Matchers::ExpectationCustomization + # @return [ExpectationCustomization] a new instance of ExpectationCustomization + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/expectation_customization.rb:8 + def initialize(method_name, args, block); end + + # Returns the value of attribute block. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/expectation_customization.rb:6 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/expectation_customization.rb:6 + def block=(_arg0); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/expectation_customization.rb:14 + def playback_onto(expectation); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:5 +class RSpec::Mocks::Matchers::HaveReceived + include ::RSpec::Mocks::Matchers::Matcher + + # @return [HaveReceived] a new instance of HaveReceived + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:12 + def initialize(method_name, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def at_least(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def at_most(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:48 + def description; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:32 + def does_not_match?(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def exactly(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:40 + def failure_message; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:44 + def failure_message_when_negated; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:23 + def matches?(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:19 + def name; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def once(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def ordered(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:67 + def setup_allowance(_subject, &_block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:71 + def setup_any_instance_allowance(_subject, &_block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:75 + def setup_any_instance_expectation(_subject, &_block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:79 + def setup_any_instance_negative_expectation(_subject, &_block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:59 + def setup_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:63 + def setup_negative_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def thrice(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def time(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def times(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def twice(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:53 + def with(*args); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:95 + def apply_constraints_to(expectation); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:112 + def capture_failure_message; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:106 + def count_constraint; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:85 + def disallow(type, reason = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:101 + def ensure_count_unconstrained; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:89 + def expect; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:123 + def expected_messages_received_in_order?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:128 + def mock_proxy; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:118 + def notify_failure_message; end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:9 +RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array) + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:10 +RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array) + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/have_received.rb:8 +RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array) + +# just a "tag" for rspec-mock matchers detection +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks.rb:125 +module RSpec::Mocks::Matchers::Matcher; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:7 +class RSpec::Mocks::Matchers::Receive + include ::RSpec::Mocks::Matchers::Matcher + + # @return [Receive] a new instance of Receive + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:10 + def initialize(message, block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_call_original(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_invoke(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_raise(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_return(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_throw(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_wrap_original(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def and_yield(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def at_least(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def at_most(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:20 + def description; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:30 + def does_not_match?(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def exactly(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:24 + def matches?(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:16 + def name; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def never(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def once(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def ordered(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:41 + def setup_allowance(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:54 + def setup_any_instance_allowance(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:46 + def setup_any_instance_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:50 + def setup_any_instance_negative_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:24 + def setup_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:30 + def setup_negative_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def thrice(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def time(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def times(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def twice(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:61 + def with(*args, &block); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:70 + def describable; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:107 + def move_block_to_last_customization(block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:90 + def setup_any_instance_method_substitute(subject, method, block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:95 + def setup_method_substitute(host, method, block, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:85 + def setup_mock_proxy_method_substitute(subject, method, block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:74 + def warn_if_any_instance(expression, subject); end +end + +# MessageExpectation objects are able to describe themselves in detail. +# We use this as a fall back when a MessageExpectation is not available. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:118 +class RSpec::Mocks::Matchers::Receive::DefaultDescribable + # @return [DefaultDescribable] a new instance of DefaultDescribable + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:119 + def initialize(message); end + + # This is much simpler for the `any_instance` case than what the + # user may want, but I'm not up for putting a bunch of effort + # into full descriptions for `any_instance` expectations at this point :(. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive.rb:126 + def description_for(verb); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:7 +class RSpec::Mocks::Matchers::ReceiveMessageChain + include ::RSpec::Mocks::Matchers::Matcher + + # @return [ReceiveMessageChain] a new instance of ReceiveMessageChain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:10 + def initialize(chain, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_call_original(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_invoke(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_raise(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_return(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_throw(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def and_yield(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:27 + def description; end + + # @raise [NegationUnsupportedError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:53 + def does_not_match?(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:48 + def matches?(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:23 + def name; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:31 + def setup_allowance(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:36 + def setup_any_instance_allowance(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:42 + def setup_any_instance_expectation(subject, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:48 + def setup_expectation(subject, &block); end + + # @raise [NegationUnsupportedError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:53 + def setup_negative_expectation(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:17 + def with(*args, &block); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:70 + def formatted_chain; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_message_chain.rb:64 + def replay_customizations(chain); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:5 +class RSpec::Mocks::Matchers::ReceiveMessages + include ::RSpec::Mocks::Matchers::Matcher + + # @return [ReceiveMessages] a new instance of ReceiveMessages + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:8 + def initialize(message_return_value_hash); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:17 + def description; end + + # @raise [NegationUnsupportedError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:29 + def does_not_match?(_subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:21 + def matches?(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:13 + def name; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:36 + def setup_allowance(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:50 + def setup_any_instance_allowance(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:43 + def setup_any_instance_expectation(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:21 + def setup_expectation(subject); end + + # @raise [NegationUnsupportedError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:29 + def setup_negative_expectation(_subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:55 + def warn_about_block; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:65 + def any_instance_of(subject); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:69 + def each_message_on(host); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/matchers/receive_messages.rb:61 + def proxy_on(subject); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:4 +class RSpec::Mocks::MessageChain + # @return [MessageChain] a new instance of MessageChain + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:7 + def initialize(object, *chain, &blk); end + + # Returns the value of attribute block. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:5 + def block; end + + # Returns the value of attribute chain. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:5 + def chain; end + + # Returns the value of attribute object. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:5 + def object; end + + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:13 + def setup_chain; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:33 + def chain_on(object, *chain, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:54 + def find_matching_expectation; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:49 + def find_matching_stub; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:38 + def format_chain(*chain, &blk); end +end + +# Represents an individual method stub or message expectation. The methods +# defined here can be used to configure how it behaves. The methods return +# `self` so that they can be chained together to form a fluent interface. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:44 +class RSpec::Mocks::MessageExpectation + include ::RSpec::Mocks::MessageExpectation::ImplementationDetails + + # Tells the object to delegate to the original unmodified method + # when it receives the message. + # + # @example + # expect(counter).to receive(:increment).and_call_original + # original_count = counter.count + # counter.increment + # expect(counter.count).to eq(original_count + 1) + # @note This is only available on partial doubles. + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:141 + def and_call_original; end + + # Tells the object to invoke a Proc when it receives the message. Given + # more than one value, the result of the first Proc is returned the first + # time the message is received, the result of the second Proc is returned + # the next time, etc, etc. + # + # If the message is received more times than there are Procs, the result of + # the last Proc is returned for every subsequent call. + # + # @example + # allow(api).to receive(:get_foo).and_invoke(-> { raise ApiTimeout }) + # api.get_foo # => raises ApiTimeout + # api.get_foo # => raises ApiTimeout + # + # allow(api).to receive(:get_foo).and_invoke(-> { raise ApiTimeout }, -> { raise ApiTimeout }, -> { :a_foo }) + # api.get_foo # => raises ApiTimeout + # api.get_foo # => rasies ApiTimeout + # api.get_foo # => :a_foo + # api.get_foo # => :a_foo + # api.get_foo # => :a_foo + # # etc + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:109 + def and_invoke(first_proc, *procs); end + + # Tells the object to raise an exception when the message is received. + # + # @example + # allow(car).to receive(:go).and_raise + # allow(car).to receive(:go).and_raise(OutOfGas) + # allow(car).to receive(:go).and_raise(OutOfGas, "At least 2 oz of gas needed to drive") + # allow(car).to receive(:go).and_raise(OutOfGas.new(2, :oz)) + # @note When you pass an exception class, the MessageExpectation will raise + # an instance of it, creating it with `exception` and passing `message` + # if specified. If the exception class initializer requires more than + # one parameters, you must pass in an instance and not the class, + # otherwise this method will raise an ArgumentError exception. + # @overload and_raise + # @overload and_raise + # @overload and_raise + # @overload and_raise + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:186 + def and_raise(*args); end + + # Tells the object to return a value when it receives the message. Given + # more than one value, the first value is returned the first time the + # message is received, the second value is returned the next time, etc, + # etc. + # + # If the message is received more times than there are values, the last + # value is returned for every subsequent call. + # + # @example + # allow(counter).to receive(:count).and_return(1) + # counter.count # => 1 + # counter.count # => 1 + # + # allow(counter).to receive(:count).and_return(1,2,3) + # counter.count # => 1 + # counter.count # => 2 + # counter.count # => 3 + # counter.count # => 3 + # counter.count # => 3 + # # etc + # @overload and_return + # @overload and_return + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:71 + def and_return(first_value, *values); end + + # Tells the object to throw a symbol (with the object if that form is + # used) when the message is received. + # + # @example + # allow(car).to receive(:go).and_throw(:out_of_gas) + # allow(car).to receive(:go).and_throw(:out_of_gas, :level => 0.1) + # @overload and_throw + # @overload and_throw + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:202 + def and_throw(*args); end + + # Decorates the stubbed method with the supplied block. The original + # unmodified method is passed to the block along with any method call + # arguments so you can delegate to it, whilst still being able to + # change what args are passed to it and/or change the return value. + # + # @example + # expect(api).to receive(:large_list).and_wrap_original do |original_method, *args, &block| + # original_method.call(*args, &block).first(10) + # end + # @note This is only available on partial doubles. + # @return [nil] No further chaining is supported after this. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:162 + def and_wrap_original(&block); end + + # Tells the object to yield one or more args to a block when the message + # is received. + # + # @example + # stream.stub(:open).and_yield(StringIO.new) + # @return [MessageExpectation] self, to support further chaining. + # @yield [@eval_context = Object.new] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:214 + def and_yield(*args, &block); end + + # Constrain a message expectation to be received at least a specific + # number of times. + # + # @example + # expect(dealer).to receive(:deal_card).at_least(9).times + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:249 + def at_least(n, &block); end + + # Constrain a message expectation to be received at most a specific + # number of times. + # + # @example + # expect(dealer).to receive(:deal_card).at_most(10).times + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:268 + def at_most(n, &block); end + + # Constrain a message expectation to be received a specific number of + # times. + # + # @example + # expect(dealer).to receive(:deal_card).exactly(10).times + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:236 + def exactly(n, &block); end + + # @return [String] a nice representation of the message expectation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:396 + def inspect; end + + # Expect a message not to be received at all. + # + # @example + # expect(car).to receive(:stop).never + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:293 + def never; end + + # Expect a message to be received exactly one time. + # + # @example + # expect(car).to receive(:go).once + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:304 + def once(&block); end + + # Expect messages to be received in a specific order. + # + # @example + # expect(api).to receive(:prepare).ordered + # expect(api).to receive(:run).ordered + # expect(api).to receive(:finish).ordered + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:379 + def ordered(&block); end + + # Expect a message to be received exactly three times. + # + # @example + # expect(car).to receive(:go).thrice + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:326 + def thrice(&block); end + + # Syntactic sugar for `exactly`, `at_least` and `at_most` + # + # @example + # expect(dealer).to receive(:deal_card).exactly(10).times + # expect(dealer).to receive(:deal_card).at_least(10).times + # expect(dealer).to receive(:deal_card).at_most(10).times + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:282 + def time(&block); end + + # Syntactic sugar for `exactly`, `at_least` and `at_most` + # + # @example + # expect(dealer).to receive(:deal_card).exactly(10).times + # expect(dealer).to receive(:deal_card).at_least(10).times + # expect(dealer).to receive(:deal_card).at_most(10).times + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:282 + def times(&block); end + + # @return [String] a nice representation of the message expectation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:396 + def to_s; end + + # Expect a message to be received exactly two times. + # + # @example + # expect(car).to receive(:go).twice + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:315 + def twice(&block); end + + # Constrains a stub or message expectation to invocations with specific + # arguments. + # + # With a stub, if the message might be received with other args as well, + # you should stub a default value first, and then stub or mock the same + # message using `with` to constrain to specific arguments. + # + # A message expectation will fail if the message is received with different + # arguments. + # + # @example + # allow(cart).to receive(:add) { :failure } + # allow(cart).to receive(:add).with(Book.new(:isbn => 1934356379)) { :success } + # cart.add(Book.new(:isbn => 1234567890)) + # # => :failure + # cart.add(Book.new(:isbn => 1934356379)) + # # => :success + # + # expect(cart).to receive(:add).with(Book.new(:isbn => 1934356379)) { :success } + # cart.add(Book.new(:isbn => 1234567890)) + # # => failed expectation + # cart.add(Book.new(:isbn => 1934356379)) + # # => passes + # @return [MessageExpectation] self, to support further chaining. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:359 + def with(*args, &block); end +end + +# Contains the parts of `MessageExpectation` that aren't part of +# rspec-mocks' public API. The class is very big and could really use +# some collaborators it delegates to for this stuff but for now this was +# the simplest way to split the public from private stuff to make it +# easier to publish the docs for the APIs we want published. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:410 +module RSpec::Mocks::MessageExpectation::ImplementationDetails + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:421 + def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:589 + def actual_received_count_matters?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:576 + def additional_expected_calls; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:533 + def advise(*args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:455 + def and_yield_receiver_to_implementation; end + + # Sets the attribute argument_list_matcher + # + # @param value the value to set the attribute argument_list_matcher to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:414 + def argument_list_matcher=(_arg0); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:488 + def called_max_times?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:565 + def description_for(verb); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:508 + def ensure_expected_ordering_received!; end + + # Returns the value of attribute error_generator. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:411 + def error_generator; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:559 + def expectation_count_type; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:451 + def expected_args; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:504 + def expected_messages_received?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:541 + def generate_error; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:513 + def ignoring_args?; end + + # Returns the value of attribute implementation. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:411 + def implementation; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:593 + def increase_actual_received_count!; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:474 + def invoke(parent_stub, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:479 + def invoke_without_incrementing_received_count(parent_stub, *args, &block); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:464 + def matches?(message, *args); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:517 + def matches_at_least_count?; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:521 + def matches_at_most_count?; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:525 + def matches_exact_count?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:495 + def matches_name_but_not_args(message, *args); end + + # Returns the value of attribute message. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:412 + def message; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:484 + def negative?; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:585 + def negative_expectation_for?(message); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:581 + def ordered?; end + + # Returns the value of attribute orig_object. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:413 + def orig_object; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:572 + def raise_out_of_order_error; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:555 + def raise_unexpected_message_args_error(args_for_multiple_calls); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:469 + def safe_invoke(parent_stub, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:529 + def similar_messages; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:418 + def type; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:537 + def unadvise(args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:499 + def verify_messages_received; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:460 + def yield_receiver_to_implementation_block?; end + + protected + + # Sets the attribute error_generator + # + # @param value the value to set the attribute error_generator to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:411 + def error_generator=(_arg0); end + + # Sets the attribute expected_from + # + # @param value the value to set the attribute expected_from to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:414 + def expected_from=(_arg0); end + + # Sets the attribute expected_received_count + # + # @param value the value to set the attribute expected_received_count to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:414 + def expected_received_count=(_arg0); end + + # Sets the attribute implementation + # + # @param value the value to set the attribute implementation to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:411 + def implementation=(_arg0); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:601 + def exception_source_id; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:633 + def has_been_invoked?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:656 + def initial_implementation_action=(action); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:660 + def inner_implementation_action=(action); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:605 + def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:637 + def raise_already_invoked_error_if_necessary(calling_customization); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:643 + def set_expected_received_count(relativity, n); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:666 + def terminal_implementation_action=(action); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:670 + def warn_about_stub_override; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:677 + def wrap_original(method_name, &block); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:4 +class RSpec::Mocks::MethodDouble + # @private + # @return [MethodDouble] a new instance of MethodDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:9 + def initialize(object, method_name, proxy); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:191 + def add_default_stub(*args, &implementation); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:141 + def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:177 + def add_simple_expectation(method_name, response, error_generator, backtrace_line); end + + # A simple stub can only return a concrete value for a message, and + # cannot match on arguments. It is used as an optimization over + # `add_stub` / `add_expectation` where it is known in advance that this + # is all that will be required of a stub, such as when passing attributes + # to the `double` example method. They do not stash or restore existing method + # definitions. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:172 + def add_simple_stub(method_name, response); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:156 + def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:150 + def build_expectation(error_generator, expectation_ordering); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:127 + def clear; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:51 + def configure_method; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:58 + def define_proxy_method; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:6 + def expectations; end + + # The type of message expectation to create has been extracted to its own + # method so that subclasses can override it. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:136 + def message_expectation_class; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:6 + def method_name; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:6 + def method_stasher; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:6 + def object; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:46 + def object_singleton_class; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:21 + def original_implementation_callable; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:34 + def original_method; end + + # The implementation of the proxied method. Subclasses may override this + # method to perform additional operations. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:79 + def proxy_method_invoked(_obj, *args, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:208 + def raise_method_not_stubbed_error; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:197 + def remove_stub; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:203 + def remove_stub_if_present; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:121 + def reset; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:85 + def restore_original_method; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:108 + def restore_original_visibility; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:21 + def save_original_implementation_callable!; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:182 + def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:97 + def show_frozen_warning; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:6 + def stubs; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:116 + def verify; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:41 + def visibility; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:230 + def definition_target; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:250 + def new_rspec_prepended_module; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:268 + def remove_method_from_definition_target; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:234 + def usable_rspec_prepended_module; end +end + +# We subclass `Module` in order to be able to easily detect our prepended module. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_double.rb:228 +class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module; end + +# Represents a method on an object that may or may not be defined. +# The method may be an instance method on a module or a method on +# any object. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:10 +class RSpec::Mocks::MethodReference + # @return [MethodReference] a new instance of MethodReference + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:15 + def initialize(object_reference, method_name); end + + # A method is defined if we are able to get a `Method` object for it. + # In that case, we can assert against metadata like the arity. + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:46 + def defined?; end + + # A method is implemented if sending the message does not result in + # a `NoMethodError`. It might be dynamically implemented by + # `method_missing`. + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:23 + def implemented?; end + + # Returns true if we definitively know that sending the method + # will result in a `NoMethodError`. + # + # This is not simply the inverse of `implemented?`: there are + # cases when we don't know if a method is implemented and + # both `implemented?` and `unimplemented?` will return false. + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:35 + def unimplemented?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:57 + def visibility; end + + # @yield [Support::MethodSignature.new(original)] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:52 + def with_signature; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:105 + def original_method; end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:11 + def for(object_reference, method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:67 + def instance_method_visibility_for(klass, method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:67 + def method_defined_at_any_visibility?(klass, method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:81 + def method_visibility_for(object, method_name); end + end +end + +# Raised when an expectation customization method (e.g. `with`, +# `and_return`) is called on a message expectation which has already been +# invoked. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:18 +class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception; end + +# Raised when a message expectation is not satisfied. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:6 +class RSpec::Mocks::MockExpectationError < ::Exception; end + +# An implementation of rspec-mocks' reference interface. +# Used when a string is passed to {ExampleMethods#object_double}, +# and when a string, named class or named module is passed to +# {ExampleMethods#instance_double}, or {ExampleMethods#class_double}. +# Represents a reference to the object named (via a constant lookup) +# by the string. +# +# @see DirectObjectReference +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:109 +class RSpec::Mocks::NamedObjectReference + # @param const_name [String] constant name + # @return [NamedObjectReference] a new instance of NamedObjectReference + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:111 + def initialize(const_name); end + + # @return [String] the constant name to replace with a double. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:121 + def const_to_replace; end + + # @return [Boolean] true if the named constant is defined, false otherwise. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:116 + def defined?; end + + # @return [String] the constant name to replace with a double. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:121 + def description; end + + # @return [Object, nil] the target of the verifying double (the named object), or + # nil if it is not defined. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:128 + def target; end + + # Yields if the reference target is loaded, providing a generic mechanism + # to optionally run a bit of code only when a reference's target is + # loaded. + # + # @yield [Object] the target object + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:137 + def when_loaded; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:143 + def object; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:31 +class RSpec::Mocks::NegationUnsupportedError < ::StandardError; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:209 +class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space + # @return [NestedSpace] a new instance of NestedSpace + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:210 + def initialize(parent); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:219 + def constant_mutator_for(name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:215 + def proxies_of(klass); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:223 + def registered?(object); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:233 + def any_instance_recorder_not_found_for(id, klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:229 + def proxy_not_found_for(id, object); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:16 +class RSpec::Mocks::NoCallbackInvocationStrategy + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:17 + def call(_doubled_module); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:149 +class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:168 + def find_method(object); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:164 + def method_defined?(object); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:160 + def method_implemented?(object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:172 + def visibility_from(object); end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/method_reference.rb:150 + def for(object_reference, method_name); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:4 +class RSpec::Mocks::ObjectReference + class << self + # Returns an appropriate Object or Module reference based + # on the given argument. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:7 + def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end + + private + + # 1.8.7 + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:31 + def anonymous_module?(mod); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:41 + def name_of(mod); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/object_reference.rb:47 +RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# Similar to an InstanceVerifyingDouble, except that it verifies against +# public methods of the given object. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:108 +class RSpec::Mocks::ObjectVerifyingDouble + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble + include ::RSpec::Mocks::ObjectVerifyingDoubleMethods +end + +# An awkward module necessary because we cannot otherwise have +# ClassVerifyingDouble inherit from Module and still share these methods. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:85 +module RSpec::Mocks::ObjectVerifyingDoubleMethods + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:89 + def as_stubbed_const(options = T.unsafe(nil)); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:96 + def __build_mock_proxy(order_group); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:4 +class RSpec::Mocks::OrderGroup + # @return [OrderGroup] a new instance of OrderGroup + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:5 + def initialize; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:48 + def clear; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:26 + def consume; end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:54 + def empty?; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:37 + def handle_order_constraint(expectation); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:16 + def invoked(message); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:21 + def ready_for?(expectation); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:12 + def register(expectation); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:43 + def verify_invocation_order(expectation); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:76 + def expectation_for(message); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:64 + def expectations_invoked_in_order?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:72 + def expected_invocations; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:68 + def invoked_expectations; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/order_group.rb:60 + def remaining_expectations; end +end + +# Raised when doubles or partial doubles are used outside of the per-test lifecycle. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:13 +class RSpec::Mocks::OutsideOfExampleError < ::StandardError; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:464 +class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy + include ::RSpec::Mocks::PartialClassDoubleProxyMethods +end + +# When we mock or stub a method on a class, we have to treat it a bit different, +# because normally singleton method definitions only affect the object on which +# they are defined, but on classes they affect subclasses, too. As a result, +# we need some special handling to get the original method. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:388 +module RSpec::Mocks::PartialClassDoubleProxyMethods + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:389 + def initialize(source_space, *args); end + + # Consider this situation: + # + # class A; end + # class B < A; end + # + # allow(A).to receive(:new) + # expect(B).to receive(:new).and_call_original + # + # When getting the original definition for `B.new`, we cannot rely purely on + # using `B.method(:new)` before our redefinition is defined on `B`, because + # `B.method(:new)` will return a method that will execute the stubbed version + # of the method on `A` since singleton methods on classes are in the lookup + # hierarchy. + # + # To do it properly, we need to find the original definition of `new` from `A` + # from _before_ `A` was stubbed, and we need to rebind it to `B` so that it will + # run with the proper `self`. + # + # That's what this method (together with `original_unbound_method_handle_from_ancestor_for`) + # does. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:414 + def original_method_handle_for(message); end + + protected + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:442 + def method_double_from_ancestor_for(message); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:437 + def original_unbound_method_handle_from_ancestor_for(message); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:452 + def superclass_proxy; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:325 +class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:339 + def add_simple_expectation(method_name, response, location); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:345 + def add_simple_stub(method_name, response); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:362 + def message_received(message, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:326 + def original_method_handle_for(message); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:357 + def reset; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:351 + def visibility_for(method_name); end + + private + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:372 + def any_instance_class_recorder_observing_method?(klass, method_name); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:4 +class RSpec::Mocks::Proxy + # @private + # @return [Proxy] a new instance of Proxy + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:23 + def initialize(object, order_group, options = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:74 + def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:88 + def add_simple_expectation(method_name, response, location); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:149 + def add_simple_stub(method_name, response); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:143 + def add_stub(method_name, opts = T.unsafe(nil), &implementation); end + + # Tells the object to ignore any messages that aren't explicitly set as + # stubs or message expectations. + # + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:61 + def as_null_object; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:93 + def build_expectation(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:126 + def check_for_unexpected_arguments(expectation); end + + # @private + # @raise [ArgumentError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:37 + def ensure_can_be_proxied!(object); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:18 + def ensure_implemented(*_args); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:190 + def has_negative_expectation?(message); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:203 + def message_received(message, *args, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:183 + def messages_arg_list; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:268 + def method_double_if_exists_for_message(message); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:54 + def null_object?; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:51 + def object; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:67 + def original_method_handle_for(_message); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:262 + def prepended_modules_of_singleton_class; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:241 + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:236 + def raise_unexpected_message_error(method_name, args); end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:176 + def received_message?(method_name, *args, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:195 + def record_message_received(message, *args, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:154 + def remove_stub(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:159 + def remove_stub_if_present(method_name); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:103 + def replay_received_message_on(expectation, &block); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:169 + def reset; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:164 + def verify; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:246 + def visibility_for(_method_name); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:285 + def find_almost_matching_expectation(method_name, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:309 + def find_almost_matching_stub(method_name, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:292 + def find_best_matching_expectation_for(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:278 + def find_matching_expectation(method_name, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:304 + def find_matching_method_stub(method_name, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:274 + def method_double_for(message); end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:252 + def prepended_modules_of(klass); end + end +end + +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:71 +RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:6 +class RSpec::Mocks::Proxy::SpecificMessage < ::Struct + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:7 + def ==(expectation); end + + # Returns the value of attribute args + # + # @return [Object] the current value of args + def args; end + + # Sets the attribute args + # + # @param value [Object] the value to set the attribute args to. + # @return [Object] the newly set value + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:6 + def args=(_); end + + # Returns the value of attribute message + # + # @return [Object] the current value of message + def message; end + + # Sets the attribute message + # + # @param value [Object] the value to set the attribute message to. + # @return [Object] the newly set value + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:6 + def message=(_); end + + # Returns the value of attribute object + # + # @return [Object] the current value of object + def object; end + + # Sets the attribute object + # + # @param value [Object] the value to set the attribute object to. + # @return [Object] the newly set value + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:6 + def object=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:469 +class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy + # @return [ProxyForNil] a new instance of ProxyForNil + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:470 + def initialize(order_group); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:478 + def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:483 + def add_stub(method_name, opts = T.unsafe(nil), &implementation); end + + # Returns the value of attribute disallow_expectations. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:475 + def disallow_expectations; end + + # Sets the attribute disallow_expectations + # + # @param value the value to set the attribute disallow_expectations to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:475 + def disallow_expectations=(_arg0); end + + # Returns the value of attribute warn_about_expectations. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:476 + def warn_about_expectations; end + + # Sets the attribute warn_about_expectations + # + # @param value the value to set the attribute warn_about_expectations to. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:476 + def warn_about_expectations=(_arg0); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:520 + def raise_error(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:490 + def set_expectation_behavior; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:515 + def warn(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:504 + def warn_or_raise!(method_name); end +end + +# Provides a default space implementation for outside +# the scope of an example. Called "root" because it serves +# as the root of the space stack. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:9 +class RSpec::Mocks::RootSpace + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:18 + def any_instance_proxy_for(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:14 + def any_instance_recorder_for(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:26 + def any_instance_recorders_from_ancestry_of(_object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:44 + def new_scope; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:10 + def proxy_for(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:22 + def register_constant_mutator(_mutator); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:36 + def registered?(_object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:30 + def reset_all; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:40 + def superclass_proxy_for(*_args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:33 + def verify_all; end + + private + + # @raise [OutsideOfExampleError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:50 + def raise_lifecycle_message; end +end + +# A message expectation that only allows concrete return values to be set +# for a message. While this same effect can be achieved using a standard +# MessageExpectation, this version is much faster and so can be used as an +# optimization. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:11 +class RSpec::Mocks::SimpleMessageExpectation + # @return [SimpleMessageExpectation] a new instance of SimpleMessageExpectation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:12 + def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:26 + def called_max_times?; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:17 + def invoke(*_); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:22 + def matches?(message, *_); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:37 + def unadvise(_); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_expectation.rb:30 + def verify_messages_received; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:57 +class RSpec::Mocks::Space + # @return [Space] a new instance of Space + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:60 + def initialize; end + + # Returns the value of attribute any_instance_mutex. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:58 + def any_instance_mutex; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:103 + def any_instance_proxy_for(klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:93 + def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end + + # Returns the value of attribute any_instance_recorders. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:58 + def any_instance_recorders; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:131 + def any_instance_recorders_from_ancestry_of(object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:89 + def constant_mutator_for(name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:111 + def ensure_registered(object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:69 + def new_scope; end + + # Returns the value of attribute proxies. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:58 + def proxies; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:107 + def proxies_of(klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:111 + def proxy_for(object); end + + # Returns the value of attribute proxy_mutex. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:58 + def proxy_mutex; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:85 + def register_constant_mutator(mutator); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:127 + def registered?(object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:78 + def reset_all; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:118 + def superclass_proxy_for(klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:73 + def verify_all; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:184 + def any_instance_recorder_not_found_for(id, klass); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:171 + def class_proxy_with_callback_verification_strategy(object, strategy); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:202 + def id_for(object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:147 + def new_mutex; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:151 + def proxy_not_found_for(id, object); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/space.rb:166 + def superclass_proxy_not_found_for(id, object); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:75 +class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:82 + def expectation(object, message, &return_block); end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/message_chain.rb:76 + def stub_chain_on(object, *chain, &blk); end + end +end + +# Provides methods for enabling and disabling the available syntaxes +# provided by rspec-mocks. +# +# @api private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:6 +module RSpec::Mocks::Syntax + class << self + # Determines where the methods like `should_receive`, and `stub` are added. + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:181 + def default_should_syntax_host; end + + # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc). + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:150 + def disable_expect(syntax_host = T.unsafe(nil)); end + + # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc). + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:89 + def disable_should(syntax_host = T.unsafe(nil)); end + + # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc). + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:110 + def enable_expect(syntax_host = T.unsafe(nil)); end + + # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc). + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:26 + def enable_should(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the expect syntax is enabled. + # + # @api private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:175 + def expect_enabled?(syntax_host = T.unsafe(nil)); end + + # Indicates whether or not the should syntax is enabled. + # + # @api private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:169 + def should_enabled?(syntax_host = T.unsafe(nil)); end + + # @api private + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:8 + def warn_about_should!; end + + # @api private + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/syntax.rb:13 + def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:63 +class RSpec::Mocks::TargetBase + include ::RSpec::Mocks::TargetDelegationInstanceMethods + extend ::RSpec::Mocks::TargetDelegationClassMethods + + # @return [TargetBase] a new instance of TargetBase + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:64 + def initialize(target); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:4 +module RSpec::Mocks::TargetDelegationClassMethods + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:14 + def delegate_not_to(matcher_method, options = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:5 + def delegate_to(matcher_method); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:28 + def disallow_negation(method_name); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:36 +module RSpec::Mocks::TargetDelegationInstanceMethods + # Returns the value of attribute target. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:37 + def target; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:45 + def define_matcher(matcher, name, &block); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:41 + def matcher_allowed?(matcher); end + + # @raise [NegationUnsupportedError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:55 + def raise_negation_unsupported(method_name, matcher); end + + # @raise [UnsupportedMatcherError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/targets.rb:49 + def raise_unsupported_matcher(method_name, matcher); end +end + +# Implements the methods needed for a pure test double. RSpec::Mocks::Double +# includes this module, and it is provided for cases where you want a +# pure test double without subclassing RSpec::Mocks::Double. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:6 +module RSpec::Mocks::TestDouble + # Creates a new test double with a `name` (that will be used in error + # messages only) + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:9 + def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end + + # This allows for comparing the mock to other objects that proxy such as + # ActiveRecords belongs_to proxy objects. By making the other object run + # the comparison, we're sure the call gets delegated to the proxy + # target. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:36 + def ==(other); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:56 + def __build_mock_proxy_unless_expired(order_group); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:61 + def __disallow_further_usage!; end + + # Tells the object to respond to all messages. If specific stub values + # are declared, they'll work as expected. If not, the receiver is + # returned. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:23 + def as_null_object; end + + # Override for default freeze implementation to prevent freezing of test + # doubles. + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:67 + def freeze; end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:41 + def inspect; end + + # Returns true if this object has received `as_null_object` + # + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:28 + def null_object?; end + + # @private + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:51 + def respond_to?(message, incl_private = T.unsafe(nil)); end + + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:46 + def to_s; end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:115 + def __build_mock_proxy(order_group); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:111 + def __mock_proxy; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:119 + def __raise_expired_error; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:105 + def assign_stubs(stubs); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:124 + def initialize_copy(other); end + + # @raise [NoMethodError] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:74 + def method_missing(message, *args, &block); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:137 +module RSpec::Mocks::TestDoubleFormatter + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:138 + def format(dbl, unwrap = T.unsafe(nil)); end + + private + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:164 + def name_desc(dbl); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:147 + def type_desc(dbl); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/test_double.rb:159 + def verified_module_desc(dbl); end + end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:316 +class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy + # source://rspec-mocks-3.11.1/lib/rspec/mocks/proxy.rb:317 + def reset; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:29 +class RSpec::Mocks::UnsupportedMatcherError < ::StandardError; end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:6 +module RSpec::Mocks::VerifyingDouble + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:51 + def initialize(doubled_module, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:39 + def __send__(name, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:20 + def method_missing(message, *args, &block); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:7 + def respond_to?(message, include_private = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_double.rb:47 + def send(name, *args, &block); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/error_generator.rb:33 +class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError; end + +# Used in place of a `VerifyingExistingMethodDouble` for the specific case +# of mocking or stubbing a `new` method on a class. In this case, we substitute +# the method signature from `#initialize` since new's signature is just `*args`. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:214 +class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble + # @yield [Support::MethodSignature.new(object.instance_method(:initialize))] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:215 + def with_signature; end +end + +# A VerifyingMethodDouble fetches the method to verify against from the +# original object, using a MethodReference. This works for pure doubles, +# but when the original object is itself the one being modified we need to +# collapse the reference and the method double into a single object so that +# we can access the original pristine method definition. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:179 +class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble + # @return [VerifyingExistingMethodDouble] a new instance of VerifyingExistingMethodDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:180 + def initialize(object, method_name, proxy); end + + # @return [Boolean] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:194 + def unimplemented?; end + + # @yield [Support::MethodSignature.new(original_implementation_callable)] + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:190 + def with_signature; end + + class << self + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:198 + def for(object, method_name, proxy); end + end +end + +# A message expectation that knows about the real implementation of the +# message being expected, so that it can verify that any expectations +# have the valid arguments. +# +# @api private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:17 +class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation + # @api private + # @return [VerifyingMessageExpectation] a new instance of VerifyingMessageExpectation + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:20 + def initialize(*args); end + + # A level of indirection is used here rather than just passing in the + # method itself, since method look up is expensive and we only want to + # do it if actually needed. + # + # Conceptually the method reference makes more sense as a constructor + # argument since it should be immutable, but it is significantly more + # straight forward to build the object in pieces so for now it stays as + # an accessor. + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:18 + def method_reference; end + + # A level of indirection is used here rather than just passing in the + # method itself, since method look up is expensive and we only want to + # do it if actually needed. + # + # Conceptually the method reference makes more sense as a constructor + # argument since it should be immutable, but it is significantly more + # straight forward to build the object in pieces so for now it stays as + # an accessor. + # + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:18 + def method_reference=(_arg0); end + + # @api private + # @private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:25 + def with(*args, &block); end + + private + + # @api private + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_message_expectation.rb:37 + def validate_expected_arguments!; end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:139 +class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble + # @return [VerifyingMethodDouble] a new instance of VerifyingMethodDouble + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:140 + def initialize(object, method_name, proxy, method_reference); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:149 + def add_expectation(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:154 + def add_stub(*args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:145 + def message_expectation_class; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:159 + def proxy_method_invoked(obj, *args, &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:164 + def validate_arguments!(actual_args); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:134 +class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy + include ::RSpec::Mocks::PartialClassDoubleProxyMethods +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:107 +class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy + include ::RSpec::Mocks::VerifyingProxyMethods + + # @return [VerifyingPartialDoubleProxy] a new instance of VerifyingPartialDoubleProxy + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:110 + def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:123 + def ensure_implemented(_method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:128 + def method_reference; end +end + +# A verifying proxy mostly acts like a normal proxy, except that it +# contains extra logic to try and determine the validity of any expectation +# set on it. This includes whether or not methods have been defined and the +# validatiy of arguments on method calls. +# +# In all other ways this behaves like a normal proxy. It only adds the +# verification behaviour to specific methods then delegates to the parent +# implementation. +# +# These checks are only activated if the doubled class has already been +# loaded, otherwise they are disabled. This allows for testing in +# isolation. +# +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:71 +class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy + include ::RSpec::Mocks::VerifyingProxyMethods + + # @return [VerifyingProxy] a new instance of VerifyingProxy + # + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:74 + def initialize(object, order_group, doubled_module, method_reference_class); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:88 + def method_reference; end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:98 + def validate_arguments!(method_name, args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:94 + def visibility_for(method_name); end +end + +# @private +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:22 +module RSpec::Mocks::VerifyingProxyMethods + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:33 + def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:28 + def add_simple_stub(method_name, *args); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:23 + def add_stub(method_name, opts = T.unsafe(nil), &implementation); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:38 + def ensure_implemented(method_name); end + + # source://rspec-mocks-3.11.1/lib/rspec/mocks/verifying_proxy.rb:48 + def ensure_publicly_implemented(method_name, _object); end +end + +# Version information for RSpec mocks. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/version.rb:4 +module RSpec::Mocks::Version; end + +# Version of RSpec mocks currently in use in SemVer format. +# +# source://rspec-mocks-3.11.1/lib/rspec/mocks/version.rb:6 +RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:54 +RSpec::SharedContext = RSpec::Core::SharedContext diff --git a/sorbet/rbi/gems/rspec-support.rbi b/sorbet/rbi/gems/rspec-support.rbi deleted file mode 100644 index ef9bbc01..00000000 --- a/sorbet/rbi/gems/rspec-support.rbi +++ /dev/null @@ -1,280 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi -# -# rspec-support-3.11.0 - -module RSpec - extend RSpec::Support::Warnings -end -module RSpec::Support - def self.class_of(object); end - def self.define_optimized_require_for_rspec(lib, &require_relative); end - def self.deregister_matcher_definition(&block); end - def self.failure_notifier; end - def self.failure_notifier=(callable); end - def self.is_a_matcher?(object); end - def self.matcher_definitions; end - def self.method_handle_for(object, method_name); end - def self.notify_failure(failure, options = nil); end - def self.register_matcher_definition(&block); end - def self.require_rspec_support(f); end - def self.rspec_description_for_object(object); end - def self.thread_local_data; end - def self.warning_notifier; end - def self.warning_notifier=(arg0); end - def self.with_failure_notifier(callable); end -end -module RSpec::Support::Version -end -class RSpec::Support::ComparableVersion - def <=>(other); end - def initialize(string); end - def segments; end - def string; end - include Comparable -end -module RSpec::Support::OS - def self.windows?; end - def self.windows_file_path?; end - def windows?; end - def windows_file_path?; end -end -module RSpec::Support::Ruby - def jruby?; end - def jruby_9000?; end - def jruby_version; end - def mri?; end - def non_mri?; end - def rbx?; end - def self.jruby?; end - def self.jruby_9000?; end - def self.jruby_version; end - def self.mri?; end - def self.non_mri?; end - def self.rbx?; end - def self.truffleruby?; end - def truffleruby?; end -end -module RSpec::Support::RubyFeatures - def caller_locations_supported?; end - def fork_supported?; end - def kw_args_supported?; end - def module_prepends_supported?; end - def module_refinement_supported?; end - def optional_and_splat_args_supported?; end - def required_kw_args_supported?; end - def ripper_supported?; end - def self.caller_locations_supported?; end - def self.fork_supported?; end - def self.kw_args_supported?; end - def self.module_prepends_supported?; end - def self.module_refinement_supported?; end - def self.optional_and_splat_args_supported?; end - def self.required_kw_args_supported?; end - def self.ripper_supported?; end - def self.supports_exception_cause?; end - def self.supports_rebinding_module_methods?; end - def self.supports_taint?; end - def supports_exception_cause?; end - def supports_rebinding_module_methods?; end - def supports_taint?; end -end -module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - def self.===(exception); end -end -class RSpec::CallerFilter - def self.first_non_rspec_line(skip_frames = nil, increment = nil); end -end -module RSpec::Support::Warnings - def deprecate(deprecated, options = nil); end - def warn_deprecation(message, options = nil); end - def warn_with(message, options = nil); end - def warning(text, options = nil); end -end -class RSpec::Support::EncodedString - def <<(string); end - def ==(*args, &block); end - def detect_source_encoding(string); end - def empty?(*args, &block); end - def encoding(*args, &block); end - def eql?(*args, &block); end - def initialize(string, encoding = nil); end - def lines(*args, &block); end - def matching_encoding(string); end - def remove_invalid_bytes(string); end - def self.pick_encoding(source_a, source_b); end - def source_encoding; end - def split(regex_or_string); end - def to_s; end - def to_str; end -end -class RSpec::Support::ReentrantMutex - def enter; end - def exit; end - def initialize; end - def synchronize; end -end -class RSpec::Support::Mutex < Thread::Mutex - def self.new; end -end -class RSpec::Support::DirectoryMaker - def self.directory_exists?(dirname); end - def self.generate_path(stack, part); end - def self.generate_stack(path); end - def self.mkdir_p(path); end -end -class RSpec::Support::MethodSignature - def arbitrary_kw_args?; end - def classify_arity(arity = nil); end - def classify_parameters; end - def could_contain_kw_args?(args); end - def description; end - def has_kw_args_in?(args); end - def initialize(method); end - def invalid_kw_args_from(given_kw_args); end - def max_non_kw_args; end - def min_non_kw_args; end - def missing_kw_args_from(given_kw_args); end - def non_kw_args_arity_description; end - def optional_kw_args; end - def required_kw_args; end - def unlimited_args?; end - def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = nil); end -end -class RSpec::Support::MethodSignatureExpectation - def empty?; end - def expect_arbitrary_keywords; end - def expect_arbitrary_keywords=(arg0); end - def expect_unlimited_arguments; end - def expect_unlimited_arguments=(arg0); end - def initialize; end - def keywords; end - def keywords=(values); end - def max_count; end - def max_count=(number); end - def min_count; end - def min_count=(number); end -end -class RSpec::Support::BlockSignature < RSpec::Support::MethodSignature - def classify_parameters; end -end -class RSpec::Support::MethodSignatureVerifier - def arbitrary_kw_args?; end - def error_message; end - def initialize(signature, args = nil); end - def invalid_kw_args; end - def kw_args; end - def max_non_kw_args; end - def min_non_kw_args; end - def missing_kw_args; end - def non_kw_args; end - def split_args(*args); end - def unlimited_args?; end - def valid?; end - def valid_non_kw_args?; end - def with_expectation(expectation); end -end -class RSpec::Support::LooseSignatureVerifier < RSpec::Support::MethodSignatureVerifier - def split_args(*args); end -end -class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher - def has_kw_args_in?(args); end - def initialize(signature); end - def invalid_kw_args_from(_kw_args); end - def missing_kw_args_from(_kw_args); end - def non_kw_args_arity_description; end - def valid_non_kw_args?(*args); end -end -module RSpec::Support::WithKeywordsWhenNeeded - def class_exec(klass, *args, &block); end - def self.class_exec(klass, *args, &block); end -end -module RSpec::Support::RecursiveConstMethods - def const_defined_on?(mod, const_name); end - def constants_defined_on(mod); end - def get_const_defined_on(mod, const_name); end - def normalize_const_name(const_name); end - def recursive_const_defined?(const_name); end - def recursive_const_get(const_name); end -end -class RSpec::Support::ObjectFormatter - def format(object); end - def initialize(max_formatted_output_length = nil); end - def max_formatted_output_length; end - def max_formatted_output_length=(arg0); end - def prepare_array(array); end - def prepare_element(element); end - def prepare_for_inspection(object); end - def prepare_hash(input_hash); end - def recursive_structure?(object); end - def self.default_instance; end - def self.format(object); end - def self.prepare_for_inspection(object); end - def sort_hash_keys(input_hash); end - def truncate_string(str, start_index, end_index); end - def with_entering_structure(structure); end -end -class RSpec::Support::ObjectFormatter::InspectableItem < Struct - def inspect; end - def pretty_print(pp); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def text; end - def text=(_); end -end -class RSpec::Support::ObjectFormatter::BaseInspector < Struct - def formatter; end - def formatter=(_); end - def inspect; end - def object; end - def object=(_); end - def pretty_print(pp); end - def self.[](*arg0); end - def self.can_inspect?(_object); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RSpec::Support::ObjectFormatter::TimeInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::DateTimeInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::BigDecimalInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def klass; end - def native_object_id; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::DelegatorInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -class RSpec::Support::ObjectFormatter::InspectableObjectInspector < RSpec::Support::ObjectFormatter::BaseInspector - def inspect; end - def self.can_inspect?(object); end -end -module RSpec::Support::FuzzyMatcher - def self.arrays_match?(expected_list, actual_list); end - def self.hashes_match?(expected_hash, actual_hash); end - def self.values_match?(expected, actual); end -end diff --git a/sorbet/rbi/gems/rspec-support@3.11.0.rbi b/sorbet/rbi/gems/rspec-support@3.11.0.rbi new file mode 100644 index 00000000..fe86cf9d --- /dev/null +++ b/sorbet/rbi/gems/rspec-support@3.11.0.rbi @@ -0,0 +1,1747 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rspec-support` gem. +# Please instead update this file by running `bin/tapioca gem rspec-support`. + +# Share the top-level RSpec namespace, because we are a core supported +# extension. +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:1 +module RSpec + extend ::RSpec::Support::Warnings + + class << self + # Used to ensure examples get reloaded between multiple runs in the same + # process and ensures user configuration is persisted. + # + # Users must invoke this if they want to clear all examples but preserve + # current configuration when they use the runner multiple times within the + # same process. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:70 + def clear_examples; end + + # Returns the global [Configuration](RSpec/Core/Configuration) object. While + # you _can_ use this method to access the configuration, the more common + # convention is to use [RSpec.configure](RSpec#configure-class_method). + # + # @example + # RSpec.configuration.drb_port = 1234 + # @see RSpec.configure + # @see Core::Configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:85 + def configuration; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def configuration=(_arg0); end + + # Yields the global configuration to a block. + # + # @example + # RSpec.configure do |config| + # config.add_formatter 'documentation' + # end + # @see Core::Configuration + # @yield [Configuration] global configuration + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:97 + def configure; end + + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:194 + def const_missing(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def context(*args, &example_group_block); end + + # The example being executed. + # + # The primary audience for this method is library authors who need access + # to the example currently being executed and also want to support all + # versions of RSpec 2 and 3. + # + # @example + # + # RSpec.configure do |c| + # # context.example is deprecated, but RSpec.current_example is not + # # available until RSpec 3.0. + # fetch_current_example = RSpec.respond_to?(:current_example) ? + # proc { RSpec.current_example } : proc { |context| context.example } + # + # c.before(:example) do + # example = fetch_current_example.call(self) + # + # # ... + # end + # end + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:122 + def current_example; end + + # Set the current example being executed. + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:128 + def current_example=(example); end + + # Get the current RSpec execution scope + # + # Returns (in order of lifecycle): + # * `:suite` as an initial value, this is outside of the test lifecycle. + # * `:before_suite_hook` during `before(:suite)` hooks. + # * `:before_context_hook` during `before(:context)` hooks. + # * `:before_example_hook` during `before(:example)` hooks and `around(:example)` before `example.run`. + # * `:example` within the example run. + # * `:after_example_hook` during `after(:example)` hooks and `around(:example)` after `example.run`. + # * `:after_context_hook` during `after(:context)` hooks. + # * `:after_suite_hook` during `after(:suite)` hooks. + # * `:suite` as a final value, again this is outside of the test lifecycle. + # + # Reminder, `:context` hooks have `:all` alias and `:example` hooks have `:each` alias. + # + # @return [Symbol] + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:154 + def current_scope; end + + # Set the current scope rspec is executing in + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:134 + def current_scope=(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def example_group(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fdescribe(*args, &example_group_block); end + + # Used to ensure examples get reloaded and user configuration gets reset to + # defaults between multiple runs in the same process. + # + # Users must invoke this if they want to have the configuration reset when + # they use the runner multiple times within the same process. Users must deal + # themselves with re-configuration of RSpec before run. + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:58 + def reset; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_context(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples_for(name, *args, &block); end + + # Internal container for global non-configuration data. + # + # @private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:160 + def world; end + + # Setters for shared global objects + # + # @api private + # + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def world=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xdescribe(*args, &example_group_block); end + end +end + +# Consistent implementation for "cleaning" the caller method to strip out +# non-rspec lines. This enables errors to be reported at the call site in +# the code using the library, which is far more useful than the particular +# internal method that raised an error. +# +# source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:8 +class RSpec::CallerFilter + class << self + # Earlier rubies do not support the two argument form of `caller`. This + # fallback is logically the same, but slower. + # + # source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:47 + def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end + end +end + +# source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:18 +RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array) + +# rubygems/core_ext/kernel_require.rb isn't actually part of rspec (obviously) but we want +# it ignored when we are looking for the first meaningful line of the backtrace outside +# of RSpec. It can show up in the backtrace as the immediate first caller +# when `CallerFilter.first_non_rspec_line` is called from the top level of a required +# file, but it depends on if rubygems is loaded or not. We don't want to have to deal +# with this complexity in our `RSpec.deprecate` calls, so we ignore it here. +# +# source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:28 +RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:20 +RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rspec-support-3.11.0/lib/rspec/support/caller_filter.rb:9 +RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core.rb:187 +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:54 +RSpec::SharedContext = RSpec::Core::SharedContext + +# source://rspec-support-3.11.0/lib/rspec/support.rb:2 +module RSpec::Support + class << self + # Used internally to get a class of a given object, even if it does not respond to #class. + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:84 + def class_of(object); end + + # Defines a helper method that is optimized to require files from the + # named lib. The passed block MUST be `{ |f| require_relative f }` + # because for `require_relative` to work properly from within the named + # lib the line of code must be IN that lib. + # + # `require_relative` is preferred when available because it is always O(1), + # regardless of the number of dirs in $LOAD_PATH. `require`, on the other + # hand, does a linear O(N) search over the dirs in the $LOAD_PATH until + # it can resolve the file relative to one of the dirs. + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:14 + def define_optimized_require_for_rspec(lib, &require_relative); end + + # Remove a previously registered matcher. Useful for cleaning up after + # yourself in specs. + # + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/matcher_definition.rb:22 + def deregister_matcher_definition(&block); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:105 + def failure_notifier; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:97 + def failure_notifier=(callable); end + + # @private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/matcher_definition.rb:27 + def is_a_matcher?(object); end + + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/matcher_definition.rb:4 + def matcher_definitions; end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:52 + def method_handle_for(object, method_name); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:110 + def notify_failure(failure, options = T.unsafe(nil)); end + + # Used internally to break cyclic dependency between mocks, expectations, + # and support. We don't currently have a consistent implementation of our + # matchers, though we are considering changing that: + # https://github.com/rspec/rspec-mocks/issues/513 + # + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/matcher_definition.rb:14 + def register_matcher_definition(&block); end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:23 + def require_rspec_core(f); end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:23 + def require_rspec_expectations(f); end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:23 + def require_rspec_matchers(f); end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:23 + def require_rspec_mocks(f); end + + # source://rspec-support-3.11.0/lib/rspec/support.rb:23 + def require_rspec_support(f); end + + # gives a string representation of an object for use in RSpec descriptions + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/matcher_definition.rb:34 + def rspec_description_for_object(object); end + + # A single thread local variable so we don't excessively pollute that namespace. + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:92 + def thread_local_data; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:132 + def warning_notifier; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:125 + def warning_notifier=(_arg0); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support.rb:115 + def with_failure_notifier(callable); end + end +end + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:137 +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + class << self + # source://rspec-support-3.11.0/lib/rspec/support.rb:142 + def ===(exception); end + end +end + +# These exceptions are dangerous to rescue as rescuing them +# would interfere with things we should not interfere with. +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:140 +RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array) + +# Deals with the slightly different semantics of block arguments. +# For methods, arguments are required unless a default value is provided. +# For blocks, arguments are optional, even if no default value is provided. +# +# However, we want to treat block args as required since you virtually +# always want to pass a value for each received argument and our +# `and_yield` has treated block args as required for many years. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:266 +class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:268 + def classify_parameters; end +end + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/comparable_version.rb:4 +class RSpec::Support::ComparableVersion + include ::Comparable + + # @return [ComparableVersion] a new instance of ComparableVersion + # + # source://rspec-support-3.11.0/lib/rspec/support/comparable_version.rb:9 + def initialize(string); end + + # source://rspec-support-3.11.0/lib/rspec/support/comparable_version.rb:13 + def <=>(other); end + + # source://rspec-support-3.11.0/lib/rspec/support/comparable_version.rb:35 + def segments; end + + # Returns the value of attribute string. + # + # source://rspec-support-3.11.0/lib/rspec/support/comparable_version.rb:7 + def string; end +end + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:102 +RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc) + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:129 +RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc) + +# source://rspec-support-3.11.0/lib/rspec/support/differ.rb:10 +class RSpec::Support::Differ + # @return [Differ] a new instance of Differ + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:67 + def initialize(opts = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:63 + def color?; end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:11 + def diff(actual, expected); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:57 + def diff_as_object(actual, expected); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:28 + def diff_as_string(actual, expected); end + + private + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:128 + def add_old_hunk_to_hunk(hunk, oldhunk); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:124 + def add_to_output(output, string); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:78 + def all_strings?(*args); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:82 + def any_multiline_strings?(*args); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:153 + def blue(text); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:115 + def build_hunks(actual, expected); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:90 + def coerce_to_string(string_or_array); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:141 + def color(text, color_code); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:161 + def color_diff(diff); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:95 + def diffably_stringify(array); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:119 + def finalize_output(output, final_line); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:137 + def format_type; end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:149 + def green(text); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:202 + def handle_encoding_errors(actual, expected); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:192 + def hash_to_string(hash); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:106 + def multiline?(string); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:86 + def no_numbers?(*args); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:74 + def no_procs?(*args); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:157 + def normal(text); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:178 + def object_to_string(object); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:145 + def red(text); end + + # source://rspec-support-3.11.0/lib/rspec/support/differ.rb:132 + def safely_flatten(array); end +end + +# Replacement for fileutils#mkdir_p because we don't want to require parts +# of stdlib in RSpec. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/directory_maker.rb:9 +class RSpec::Support::DirectoryMaker + class << self + # Implements nested directory construction + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/directory_maker.rb:13 + def mkdir_p(path); end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/directory_maker.rb:55 + def directory_exists?(dirname); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/directory_maker.rb:50 + def generate_path(stack, part); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/directory_maker.rb:47 + def generate_stack(path); end + end +end + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:4 +class RSpec::Support::EncodedString + # @return [EncodedString] a new instance of EncodedString + # + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:14 + def initialize(string, encoding = T.unsafe(nil)); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:26 + def <<(string); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:23 + def ==(*args, &block); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:23 + def empty?(*args, &block); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:23 + def encoding(*args, &block); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:23 + def eql?(*args, &block); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:23 + def lines(*args, &block); end + + # Returns the value of attribute source_encoding. + # + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:19 + def source_encoding; end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:39 + def split(regex_or_string); end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:44 + def to_s; end + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:44 + def to_str; end + + private + + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:137 + def detect_source_encoding(string); end + + # Encoding Exceptions: + # + # Raised by Encoding and String methods: + # Encoding::UndefinedConversionError: + # when a transcoding operation fails + # if the String contains characters invalid for the target encoding + # e.g. "\x80".encode('UTF-8','ASCII-8BIT') + # vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>') + # # => '<undef>' + # Encoding::CompatibilityError + # when Encoding.compatibile?(str1, str2) is nil + # e.g. utf_16le_emoji_string.split("\n") + # e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string + # Encoding::InvalidByteSequenceError: + # when the string being transcoded contains a byte invalid for + # either the source or target encoding + # e.g. "\x80".encode('UTF-8','US-ASCII') + # vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>') + # # => '<byte>' + # ArgumentError + # when operating on a string with invalid bytes + # e.g."\x80".split("\n") + # TypeError + # when a symbol is passed as an encoding + # Encoding.find(:"UTF-8") + # when calling force_encoding on an object + # that doesn't respond to #to_str + # + # Raised by transcoding methods: + # Encoding::ConverterNotFoundError: + # when a named encoding does not correspond with a known converter + # e.g. 'abc'.force_encoding('UTF-8').encode('foo') + # or a converter path cannot be found + # e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule') + # + # Raised by byte <-> char conversions + # RangeError: out of char range + # e.g. the UTF-16LE emoji: 128169.chr + # + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:91 + def matching_encoding(string); end + + # http://stackoverflow.com/a/8711118/879854 + # Loop over chars in a string replacing chars + # with invalid encoding, which is a pretty good proxy + # for the invalid byte sequence that causes an ArgumentError + # + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:122 + def remove_invalid_bytes(string); end + + class << self + # source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:141 + def pick_encoding(source_a, source_b); end + end +end + +# Ruby's default replacement string is: +# U+FFFD ("\xEF\xBF\xBD"), for Unicode encoding forms, else +# ? ("\x3F") +# +# source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:12 +RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String) + +# source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:7 +RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String) + +# Reduce allocations by storing constants. +# +# source://rspec-support-3.11.0/lib/rspec/support/encoded_string.rb:6 +RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String) + +# Provides a means to fuzzy-match between two arbitrary objects. +# Understands array/hash nesting. Uses `===` or `==` to +# perform the matching. +# +# source://rspec-support-3.11.0/lib/rspec/support/fuzzy_matcher.rb:6 +module RSpec::Support::FuzzyMatcher + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/fuzzy_matcher.rb:8 + def values_match?(expected, actual); end + + private + + # @private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/fuzzy_matcher.rb:27 + def arrays_match?(expected_list, actual_list); end + + # @private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/fuzzy_matcher.rb:36 + def hashes_match?(expected_hash, actual_hash); end + end +end + +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:7 +class RSpec::Support::HunkGenerator + # @return [HunkGenerator] a new instance of HunkGenerator + # + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:8 + def initialize(actual, expected); end + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:13 + def hunks; end + + private + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:30 + def actual_lines; end + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:34 + def build_hunk(piece); end + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:42 + def context_lines; end + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:22 + def diffs; end + + # source://rspec-support-3.11.0/lib/rspec/support/hunk_generator.rb:26 + def expected_lines; end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support.rb:38 +RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# Allows matchers to be used instead of providing keyword arguments. In +# practice, when this happens only the arity of the method is verified. +# +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:391 +class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier + private + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:394 + def split_args(*args); end +end + +# If a matcher is used in a signature in place of keyword arguments, all +# keyword argument validation needs to be skipped since the matcher is +# opaque. +# +# Instead, keyword arguments will be validated when the method is called +# and they are actually known. +# +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:411 +class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher + # @return [SignatureWithKeywordArgumentsMatcher] a new instance of SignatureWithKeywordArgumentsMatcher + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:412 + def initialize(signature); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:432 + def has_kw_args_in?(args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:420 + def invalid_kw_args_from(_kw_args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:416 + def missing_kw_args_from(_kw_args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:424 + def non_kw_args_arity_description; end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:428 + def valid_non_kw_args?(*args); end +end + +# Extracts info about the number of arguments and allowed/required +# keyword args of a given method. +# +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:11 +class RSpec::Support::MethodSignature + # @return [MethodSignature] a new instance of MethodSignature + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:14 + def initialize(method); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:96 + def arbitrary_kw_args?; end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:36 + def classify_arity(arity = T.unsafe(nil)); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:104 + def classify_parameters; end + + # Without considering what the last arg is, could it + # contain keyword arguments? + # + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:90 + def could_contain_kw_args?(args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:49 + def description; end + + # If the last argument is Hash, Ruby will treat only symbol keys as keyword arguments + # the rest will be grouped in another Hash and passed as positional argument. + # + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:82 + def has_kw_args_in?(args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:75 + def invalid_kw_args_from(given_kw_args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:12 + def max_non_kw_args; end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:12 + def min_non_kw_args; end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:71 + def missing_kw_args_from(given_kw_args); end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:21 + def non_kw_args_arity_description; end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:12 + def optional_kw_args; end + + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:12 + def required_kw_args; end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:100 + def unlimited_args?; end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:29 + def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end +end + +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:160 +RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float) + +# Encapsulates expectations about the number of arguments and +# allowed/required keyword args of a given method. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:217 +class RSpec::Support::MethodSignatureExpectation + # @api private + # @return [MethodSignatureExpectation] a new instance of MethodSignatureExpectation + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:218 + def initialize; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:245 + def empty?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:229 + def expect_arbitrary_keywords; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:229 + def expect_arbitrary_keywords=(_arg0); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:229 + def expect_unlimited_arguments; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:229 + def expect_unlimited_arguments=(_arg0); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:227 + def keywords; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:252 + def keywords=(values); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:227 + def max_count; end + + # @api private + # @raise [ArgumentError] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:231 + def max_count=(number); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:227 + def min_count; end + + # @api private + # @raise [ArgumentError] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:238 + def min_count=(number); end +end + +# Abstract base class for signature verifiers. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:278 +class RSpec::Support::MethodSignatureVerifier + # @api private + # @return [MethodSignatureVerifier] a new instance of MethodSignatureVerifier + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:281 + def initialize(signature, args = T.unsafe(nil)); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:324 + def error_message; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:279 + def kw_args; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:279 + def max_non_kw_args; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:279 + def min_non_kw_args; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:279 + def non_kw_args; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:316 + def valid?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:288 + def with_expectation(expectation); end + + private + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:355 + def arbitrary_kw_args?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:351 + def invalid_kw_args; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:347 + def missing_kw_args; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:363 + def split_args(*args); end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:359 + def unlimited_args?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:343 + def valid_non_kw_args?; end +end + +# On 1.9 and up, this is in core, so we just use the real one +# +# source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:65 +class RSpec::Support::Mutex < ::Thread::Mutex + class << self + # source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:68 + def new; end + end +end + +# If you mock Mutex.new you break our usage of Mutex, so +# instead we capture the original method to return Mutexs. +# +# source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:66 +RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method) + +# Provides query methods for different OS or OS features. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:9 +module RSpec::Support::OS + private + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:12 + def windows?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:16 + def windows_file_path?; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:12 + def windows?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:16 + def windows_file_path?; end + end +end + +# Provide additional output details beyond what `inspect` provides when +# printing Time, DateTime, or BigDecimal +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:8 +class RSpec::Support::ObjectFormatter + # @api private + # @return [ObjectFormatter] a new instance of ObjectFormatter + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:27 + def initialize(max_formatted_output_length = T.unsafe(nil)); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:32 + def format(object); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:11 + def max_formatted_output_length; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:11 + def max_formatted_output_length=(_arg0); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:68 + def prepare_array(array); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:92 + def prepare_element(element); end + + # Prepares the provided object to be formatted by wrapping it as needed + # in something that, when `inspect` is called on it, will produce the + # desired output. + # + # This allows us to apply the desired formatting to hash/array data structures + # at any level of nesting, simply by walking that structure and replacing items + # with custom items that have `inspect` defined to return the desired output + # for that item. Then we can just use `Array#inspect` or `Hash#inspect` to + # format the entire thing. + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:56 + def prepare_for_inspection(object); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:74 + def prepare_hash(input_hash); end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:111 + def recursive_structure?(object); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:84 + def sort_hash_keys(input_hash); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:104 + def with_entering_structure(structure); end + + private + + # Returns the substring defined by the start_index and end_index + # If the string ends with a partial ANSI code code then that + # will be removed as printing partial ANSI + # codes to the terminal can lead to corruption + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:266 + def truncate_string(str, start_index, end_index); end + + class << self + # Methods are deferred to a default instance of the class to maintain the interface + # For example, calling ObjectFormatter.format is still possible + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:15 + def default_instance; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:19 + def format(object); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:23 + def prepare_for_inspection(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:125 +class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct + # Returns the value of attribute formatter + # + # @return [Object] the current value of formatter + def formatter; end + + # Sets the attribute formatter + # + # @param value [Object] the value to set the attribute formatter to. + # @return [Object] the newly set value + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:125 + def formatter=(_); end + + # @api private + # @raise [NotImplementedError] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:130 + def inspect; end + + # Returns the value of attribute object + # + # @return [Object] the current value of object + def object; end + + # Sets the attribute object + # + # @param value [Object] the value to set the attribute object to. + # @return [Object] the newly set value + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:125 + def object=(_); end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:134 + def pretty_print(pp); end + + class << self + def [](*_arg0); end + + # @api private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:126 + def can_inspect?(_object); end + + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:175 +class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:180 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:176 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:157 +class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # ActiveSupport sometimes overrides inspect. If `ActiveSupport` is + # defined use a custom format string that includes more time precision. + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:166 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:160 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:158 +RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:222 +class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:227 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:223 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:185 +class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:190 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:186 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:9 +RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:245 +RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:115 +class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:116 + def inspect; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:120 + def pretty_print(pp); end + + # Returns the value of attribute text + # + # @return [Object] the current value of text + def text; end + + # Sets the attribute text + # + # @param value [Object] the value to set the attribute text to. + # @return [Object] the newly set value + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:115 + def text=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:232 +class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:240 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:233 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:139 +class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # for 1.8.7 + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:147 + def inspect; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:142 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:140 +RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:195 +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:205 + def inspect; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:209 + def klass; end + + # http://stackoverflow.com/a/2818916 + # + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:214 + def native_object_id; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:198 + def can_inspect?(object); end + end +end + +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/object_formatter.rb:196 +RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String) + +# Provides recursive constant lookup methods useful for +# constant stubbing. +# +# source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:5 +module RSpec::Support::RecursiveConstMethods + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:43 + def const_defined_on?(mod, const_name); end + + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:51 + def constants_defined_on(mod); end + + # @raise [NameError] + # + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:47 + def get_const_defined_on(mod, const_name); end + + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:71 + def normalize_const_name(const_name); end + + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:62 + def recursive_const_defined?(const_name); end + + # source://rspec-support-3.11.0/lib/rspec/support/recursive_const_methods.rb:56 + def recursive_const_get(const_name); end +end + +# Allows a thread to lock out other threads from a critical section of code, +# while allowing the thread with the lock to reenter that section. +# +# Based on Monitor as of 2.2 - +# https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9 +# +# Depends on Mutex, but Mutex is only available as part of core since 1.9.1: +# exists - http://ruby-doc.org/core-1.9.1/Mutex.html +# dne - http://ruby-doc.org/core-1.9.0/Mutex.html +# +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:14 +class RSpec::Support::ReentrantMutex + # @return [ReentrantMutex] a new instance of ReentrantMutex + # + # source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:15 + def initialize; end + + # source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:21 + def synchronize; end + + private + + # source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:46 + def enter; end + + # source://rspec-support-3.11.0/lib/rspec/support/reentrant_mutex.rb:52 + def exit; end +end + +# Provides query methods for different rubies +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:24 +module RSpec::Support::Ruby + private + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:27 + def jruby?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:35 + def jruby_9000?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:31 + def jruby_version; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:47 + def mri?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:43 + def non_mri?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:39 + def rbx?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:51 + def truffleruby?; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:27 + def jruby?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:35 + def jruby_9000?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:31 + def jruby_version; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:47 + def mri?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:43 + def non_mri?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:39 + def rbx?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:51 + def truffleruby?; end + end +end + +# Provides query methods for ruby features that differ among +# implementations. +# +# @api private +# +# source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:60 +module RSpec::Support::RubyFeatures + private + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:83 + def caller_locations_supported?; end + + # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true, + # but when you try to fork, it raises an error: + # NotImplementedError: fork is not available on this platform + # + # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop + # this special case. + # + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:74 + def fork_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:130 + def kw_args_supported?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:186 + def module_prepends_supported?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:182 + def module_refinement_supported?; end + + # @api private + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:79 + def optional_and_splat_args_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:134 + def required_kw_args_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:120 + def ripper_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:88 + def supports_exception_cause?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:138 + def supports_rebinding_module_methods?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:98 + def supports_taint?; end + + class << self + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:83 + def caller_locations_supported?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:74 + def fork_supported?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:130 + def kw_args_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:186 + def module_prepends_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:182 + def module_refinement_supported?; end + + # @api private + # @return [Boolean] + # + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:79 + def optional_and_splat_args_supported?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:134 + def required_kw_args_supported?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:120 + def ripper_supported?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:88 + def supports_exception_cause?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:138 + def supports_rebinding_module_methods?; end + + # source://rspec-support-3.11.0/lib/rspec/support/ruby_features.rb:98 + def supports_taint?; end + end +end + +# Figures out wether a given method can accept various arguments. +# Surprisingly non-trivial. +# +# @private +# +# source://rspec-support-3.11.0/lib/rspec/support/method_signature_verifier.rb:385 +RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier + +# source://rspec-support-3.11.0/lib/rspec/support/version.rb:3 +module RSpec::Support::Version; end + +# source://rspec-support-3.11.0/lib/rspec/support/version.rb:4 +RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String) + +# source://rspec-support-3.11.0/lib/rspec/support/warnings.rb:6 +module RSpec::Support::Warnings + # source://rspec-support-3.11.0/lib/rspec/support/warnings.rb:7 + def deprecate(deprecated, options = T.unsafe(nil)); end + + # Used internally to print deprecation warnings + # when rspec-core isn't loaded + # + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/warnings.rb:15 + def warn_deprecation(message, options = T.unsafe(nil)); end + + # Used internally to print longer warnings + # + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/warnings.rb:29 + def warn_with(message, options = T.unsafe(nil)); end + + # Used internally to print warnings + # + # @private + # + # source://rspec-support-3.11.0/lib/rspec/support/warnings.rb:22 + def warning(text, options = T.unsafe(nil)); end +end + +# source://rspec-support-3.11.0/lib/rspec/support/with_keywords_when_needed.rb:5 +module RSpec::Support::WithKeywordsWhenNeeded + private + + # Remove this in RSpec 4 in favour of explictly passed in kwargs where + # this is used. Works around a warning in Ruby 2.7 + # + # source://rspec-support-3.11.0/lib/rspec/support/with_keywords_when_needed.rb:15 + def class_exec(klass, *args, &block); end + + class << self + # source://rspec-support-3.11.0/lib/rspec/support/with_keywords_when_needed.rb:15 + def class_exec(klass, *args, &block); end + end +end diff --git a/sorbet/rbi/gems/rspec.rbi b/sorbet/rbi/gems/rspec.rbi deleted file mode 100644 index 924aab5a..00000000 --- a/sorbet/rbi/gems/rspec.rbi +++ /dev/null @@ -1,15 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi -# -# rspec-3.11.0 - -module RSpec -end -module RSpec::Version -end diff --git a/sorbet/rbi/gems/rspec@3.11.0.rbi b/sorbet/rbi/gems/rspec@3.11.0.rbi new file mode 100644 index 00000000..39b75848 --- /dev/null +++ b/sorbet/rbi/gems/rspec@3.11.0.rbi @@ -0,0 +1,88 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rspec` gem. +# Please instead update this file by running `bin/tapioca gem rspec`. + +# source://rspec-3.11.0/lib/rspec/version.rb:1 +module RSpec + class << self + # source://rspec-core-3.11.0/lib/rspec/core.rb:70 + def clear_examples; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:85 + def configuration; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def configuration=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:97 + def configure; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:194 + def const_missing(name); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def context(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:122 + def current_example; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:128 + def current_example=(example); end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:154 + def current_scope; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:134 + def current_scope=(scope); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def describe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def example_group(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def fdescribe(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:58 + def reset; end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_context(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core/shared_example_group.rb:110 + def shared_examples_for(name, *args, &block); end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:160 + def world; end + + # source://rspec-core-3.11.0/lib/rspec/core.rb:49 + def world=(_arg0); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xcontext(*args, &example_group_block); end + + # source://rspec-core-3.11.0/lib/rspec/core/dsl.rb:42 + def xdescribe(*args, &example_group_block); end + end +end + +# source://rspec-core-3.11.0/lib/rspec/core.rb:187 +RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash) + +# source://rspec-core-3.11.0/lib/rspec/core/shared_context.rb:54 +RSpec::SharedContext = RSpec::Core::SharedContext + +# source://rspec-3.11.0/lib/rspec/version.rb:2 +module RSpec::Version; end + +# source://rspec-3.11.0/lib/rspec/version.rb:3 +RSpec::Version::STRING = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rubocop-ast.rbi b/sorbet/rbi/gems/rubocop-ast.rbi deleted file mode 100644 index 299b46c7..00000000 --- a/sorbet/rbi/gems/rubocop-ast.rbi +++ /dev/null @@ -1,1386 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-ast/all/rubocop-ast.rbi -# -# rubocop-ast-1.19.1 - -module RuboCop -end -module RuboCop::AST - extend RuboCop::AST::RuboCopCompatibility -end -module RuboCop::AST::Ext -end -module RuboCop::AST::Ext::Range - def line_span(exclude_end: nil); end -end -class Parser::Source::Range - include RuboCop::AST::Ext::Range -end -module RuboCop::AST::Ext::RangeMinMax -end -class RuboCop::AST::NodePattern - def ==(other); end - def as_json(_options = nil); end - def ast; end - def captures(*args, &block); end - def encode_with(coder); end - def eql?(other); end - def freeze; end - def init_with(coder); end - def initialize(str, compiler: nil); end - def marshal_dump; end - def marshal_load(pattern); end - def match(*args, **rest, &block); end - def match_code; end - def named_parameters(*args, &block); end - def pattern; end - def positional_parameters(*args, &block); end - def self.descend(element, &block); end - def to_s; end - extend Forwardable - include RuboCop::AST::NodePattern::MethodDefiner -end -module RuboCop::AST::NodePattern::MethodDefiner - def as_lambda; end - def compile_as_lambda; end - def compile_init; end - def def_helper(base, method_name, **defaults); end - def def_node_matcher(base, method_name, **defaults); end - def def_node_search(base, method_name, **defaults); end - def emit_keyword_list(forwarding: nil); end - def emit_lambda_code; end - def emit_method_code; end - def emit_node_search(method_name); end - def emit_node_search_body(method_name, prelude:, on_match:); end - def emit_param_list; end - def emit_params(*first, forwarding: nil); end - def emit_retval; end - def emit_yield_capture(when_no_capture = nil, yield_with: nil); end - def wrapping_block(method_name, **defaults); end -end -module RuboCop::AST::NodePattern::Macros - def def_node_matcher(method_name, pattern_str, **keyword_defaults); end - def def_node_search(method_name, pattern_str, **keyword_defaults); end -end -class RuboCop::AST::NodePattern::Invalid < StandardError -end -module RuboCop::AST::Descendence - def child_nodes; end - def descendants; end - def each_child_node(*types); end - def each_descendant(*types, &block); end - def each_node(*types, &block); end - def visit_descendants(types, &block); end -end -class RuboCop::AST::NodePattern::Builder - def emit_atom(type, value); end - def emit_call(type, selector, args = nil); end - def emit_capture(capture_token, node); end - def emit_list(type, _begin, children, _end); end - def emit_subsequence(node_list); end - def emit_unary_op(type, _operator = nil, *children); end - def emit_union(begin_t, pattern_lists, end_t); end - def n(type, *args); end - def optimizable_as_set?(children); end - def union_children(pattern_lists); end -end -class RuboCop::AST::NodePattern::Comment - def ==(other); end - def initialize(range); end - def inspect; end - def loc; end - def location; end - def text; end -end -class RuboCop::AST::NodePattern::Compiler - def bind(*args, &block); end - def binding; end - def captures; end - def compile_as_atom(node); end - def compile_as_node_pattern(node, **options); end - def compile_sequence(sequence, var:); end - def each_union(enum, &block); end - def enforce_same_captures(enum); end - def freeze; end - def initialize; end - def named_parameter(name); end - def named_parameters; end - def new_capture; end - def next_capture; end - def parser; end - def positional_parameter(number); end - def positional_parameters; end - def with_temp_variables(*names, &block); end - extend Forwardable -end -class RuboCop::AST::NodePattern::Compiler::Subcompiler - def compile(node); end - def compiler; end - def do_compile; end - def initialize(compiler); end - def node; end - def self.inherited(base); end - def self.method_added(method); end - def self.registry; end -end -class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler - def visit_const; end - def visit_named_parameter; end - def visit_number; end - def visit_other_type; end - def visit_positional_parameter; end - def visit_regexp; end - def visit_set; end - def visit_string; end - def visit_symbol; end - def visit_unify; end -end -class RuboCop::AST::NodePattern::Compiler::Binding - def bind(name); end - def forbid(names); end - def initialize; end - def union_bind(enum); end -end -class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler - def access; end - def access_element; end - def access_node; end - def compile_args(arg_list, first: nil); end - def compile_guard_clause; end - def compile_value_match(value); end - def initialize(compiler, var: nil, access: nil, seq_head: nil); end - def multiple_access(kind); end - def seq_head; end - def visit_ascend; end - def visit_capture; end - def visit_descend; end - def visit_function_call; end - def visit_intersection; end - def visit_negation; end - def visit_node_type; end - def visit_other_type; end - def visit_predicate; end - def visit_sequence; end - def visit_unify; end - def visit_union; end - def visit_wildcard; end -end -class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < RuboCop::AST::NodePattern::Compiler::Subcompiler - def compile(node); end - def compile_and_advance(term); end - def compile_any_order_branches(matched_var); end - def compile_any_order_else; end - def compile_captured_repetition(child_code, child_captures); end - def compile_case(when_branches, else_code); end - def compile_child_nb_guard(arity_range); end - def compile_cur_index; end - def compile_index(cur = nil); end - def compile_loop(term); end - def compile_loop_advance(to = nil); end - def compile_matched(kind); end - def compile_max_matched; end - def compile_min_check; end - def compile_remaining; end - def compile_sequence; end - def compile_terms(children = nil, last_arity = nil); end - def compile_union_forks; end - def cur_index; end - def empty_loop; end - def handle_prev; end - def in_sync; end - def initialize(compiler, sequence:, var:); end - def merge_forks!(forks); end - def preserve_union_start(forks); end - def remaining_arities(children, last_arity); end - def sync; end - def use_index_from_end; end - def visit_any_order; end - def visit_capture; end - def visit_other_type; end - def visit_repetition; end - def visit_rest; end - def visit_union; end - def within_loop; end -end -class RuboCop::AST::NodePattern::LexerRex - def action; end - def filename; end - def filename=(arg0); end - def location; end - def match; end - def matches; end - def next_token; end - def parse(str); end - def parse_file(path); end - def scanner_class; end - def ss; end - def ss=(arg0); end - def state; end - def state=(arg0); end -end -class RuboCop::AST::NodePattern::LexerRex::LexerError < StandardError -end -class RuboCop::AST::NodePattern::LexerRex::ScanError < RuboCop::AST::NodePattern::LexerRex::LexerError -end -class RuboCop::AST::NodePattern::Lexer < RuboCop::AST::NodePattern::LexerRex - def comments; end - def do_parse; end - def emit(type); end - def emit_comment; end - def emit_regexp; end - def initialize(source); end - def source_buffer; end - def token(type, value); end - def tokens; end -end -class RuboCop::AST::NodePattern::Node < Parser::AST::Node - def arity; end - def arity_range; end - def capture?; end - def child; end - def children_nodes; end - def in_sequence_head; end - def matches_within_set?; end - def nb_captures; end - def rest?; end - def variadic?; end - def with(type: nil, children: nil, location: nil); end - extend Forwardable - include RuboCop::AST::Descendence -end -module RuboCop::AST::NodePattern::Node::ForbidInSeqHead - def in_sequence_head; end -end -class RuboCop::AST::NodePattern::Node::Capture < RuboCop::AST::NodePattern::Node - def arity(*args, &block); end - def capture?; end - def in_sequence_head; end - def nb_captures; end - def rest?(*args, &block); end -end -class RuboCop::AST::NodePattern::Node::Sequence < RuboCop::AST::NodePattern::Node - def initialize(type, children = nil, properties = nil); end - include RuboCop::AST::NodePattern::Node::ForbidInSeqHead -end -class RuboCop::AST::NodePattern::Node::Predicate < RuboCop::AST::NodePattern::Node - def arg_list; end - def method_name; end -end -class RuboCop::AST::NodePattern::Node::Repetition < RuboCop::AST::NodePattern::Node - def arity; end - def operator; end - include RuboCop::AST::NodePattern::Node::ForbidInSeqHead -end -class RuboCop::AST::NodePattern::Node::Rest < RuboCop::AST::NodePattern::Node - def arity; end - def in_sequence_head; end - def rest?; end -end -class RuboCop::AST::NodePattern::Node::AnyOrder < RuboCop::AST::NodePattern::Node - def arity; end - def ends_with_rest?; end - def rest_node; end - def term_nodes; end - include RuboCop::AST::NodePattern::Node::ForbidInSeqHead -end -class RuboCop::AST::NodePattern::Node::Subsequence < RuboCop::AST::NodePattern::Node - def arity; end - def in_sequence_head; end - include RuboCop::AST::NodePattern::Node::ForbidInSeqHead -end -class RuboCop::AST::NodePattern::Node::Union < RuboCop::AST::NodePattern::Node - def arity; end - def in_sequence_head; end -end -class RuboCop::AST::NodePattern::Parser < Racc::Parser - def _reduce_10(val, _values); end - def _reduce_11(val, _values); end - def _reduce_13(val, _values); end - def _reduce_14(val, _values); end - def _reduce_15(val, _values); end - def _reduce_16(val, _values); end - def _reduce_17(val, _values); end - def _reduce_18(val, _values); end - def _reduce_19(val, _values); end - def _reduce_2(val, _values); end - def _reduce_20(val, _values); end - def _reduce_21(val, _values); end - def _reduce_22(val, _values); end - def _reduce_25(val, _values); end - def _reduce_26(val, _values); end - def _reduce_3(val, _values); end - def _reduce_33(val, _values); end - def _reduce_37(val, _values); end - def _reduce_38(val, _values); end - def _reduce_39(val, _values); end - def _reduce_4(val, _values); end - def _reduce_40(val, _values); end - def _reduce_41(val, _values); end - def _reduce_42(val, _values); end - def _reduce_43(val, _values); end - def _reduce_44(val, _values); end - def _reduce_45(val, _values); end - def _reduce_46(val, _values); end - def _reduce_5(val, _values); end - def _reduce_6(val, _values); end - def _reduce_7(val, _values); end - def _reduce_8(val, _values); end - def _reduce_9(val, _values); end - def _reduce_none(val, _values); end - def emit_atom(*args, &block); end - def emit_call(*args, &block); end - def emit_capture(*args, &block); end - def emit_list(*args, &block); end - def emit_unary_op(*args, &block); end - def emit_union(*args, &block); end - def enforce_unary(node); end - def initialize(builder = nil); end - def inspect; end - def next_token(*args, &block); end - def on_error(token, val, _vstack); end - def parse(source); end - extend Forwardable -end -module RuboCop::AST::NodePattern::Sets - def self.[](set); end - def self.name(set); end - def self.uniq(name); end -end -module RuboCop::AST::Sexp - def s(type, *children); end -end -class RuboCop::AST::Node < Parser::AST::Node - def __ENCODING___type?; end - def __FILE___type?; end - def __LINE___type?; end - def alias_type?; end - def ancestors; end - def and_asgn_type?; end - def and_type?; end - def arg_expr_type?; end - def arg_type?; end - def args_type?; end - def argument?; end - def argument_type?; end - def array_pattern_type?; end - def array_pattern_with_tail_type?; end - def array_type?; end - def assignment?; end - def assignment_or_similar?(param0 = nil); end - def back_ref_type?; end - def basic_conditional?; end - def basic_literal?; end - def begin_type?; end - def begin_value_used?; end - def block_pass_type?; end - def block_type?; end - def blockarg_expr_type?; end - def blockarg_type?; end - def boolean_type?; end - def break_type?; end - def call_type?; end - def case_if_value_used?; end - def case_match_type?; end - def case_type?; end - def casgn_type?; end - def cbase_type?; end - def chained?; end - def class_constructor?(param0 = nil); end - def class_definition?(param0 = nil); end - def class_type?; end - def complete!; end - def complete?; end - def complex_type?; end - def conditional?; end - def const_name; end - def const_pattern_type?; end - def const_type?; end - def csend_type?; end - def cvar_type?; end - def cvasgn_type?; end - def def_type?; end - def defined_module0(param0 = nil); end - def defined_module; end - def defined_module_name; end - def defined_type?; end - def defs_type?; end - def dstr_type?; end - def dsym_type?; end - def each_ancestor(*types, &block); end - def eflipflop_type?; end - def empty_else_type?; end - def empty_source?; end - def ensure_type?; end - def equals_asgn?; end - def erange_type?; end - def false_type?; end - def falsey_literal?; end - def find_pattern_type?; end - def first_line; end - def float_type?; end - def for_type?; end - def for_value_used?; end - def forward_arg_type?; end - def forward_args_type?; end - def forwarded_args_type?; end - def global_const?(param0 = nil, param1); end - def guard_clause?; end - def gvar_type?; end - def gvasgn_type?; end - def hash_pattern_type?; end - def hash_type?; end - def ident_type?; end - def if_guard_type?; end - def if_type?; end - def iflipflop_type?; end - def immutable_literal?; end - def in_match_type?; end - def in_pattern_type?; end - def index_type?; end - def indexasgn_type?; end - def initialize(type, children = nil, properties = nil); end - def int_type?; end - def irange_type?; end - def ivar_type?; end - def ivasgn_type?; end - def keyword?; end - def kwarg_type?; end - def kwargs_type?; end - def kwbegin_type?; end - def kwnilarg_type?; end - def kwoptarg_type?; end - def kwrestarg_type?; end - def kwsplat_type?; end - def lambda?(param0 = nil); end - def lambda_or_proc?(param0 = nil); end - def lambda_type?; end - def last_line; end - def left_sibling; end - def left_siblings; end - def line_count; end - def literal?; end - def loop_keyword?; end - def lvar_type?; end - def lvasgn_type?; end - def masgn_type?; end - def match_alt_type?; end - def match_as_type?; end - def match_current_line_type?; end - def match_guard_clause?(param0 = nil); end - def match_nil_pattern_type?; end - def match_pattern_p_type?; end - def match_pattern_type?; end - def match_rest_type?; end - def match_var_type?; end - def match_with_lvasgn_type?; end - def match_with_trailing_comma_type?; end - def mlhs_type?; end - def module_definition?(param0 = nil); end - def module_type?; end - def multiline?; end - def mutable_literal?; end - def new_class_or_module_block?(param0 = nil); end - def next_type?; end - def nil_type?; end - def node_parts; end - def nonempty_line_count; end - def not_type?; end - def nth_ref_type?; end - def numargs_type?; end - def numblock_type?; end - def numeric_type?; end - def objc_kwarg_type?; end - def objc_restarg_type?; end - def objc_varargs_type?; end - def op_asgn_type?; end - def operator_keyword?; end - def optarg_type?; end - def or_asgn_type?; end - def or_type?; end - def pair_type?; end - def parent; end - def parent=(node); end - def parent?; end - def parent_module_name; end - def parent_module_name_for_block(ancestor); end - def parent_module_name_for_sclass(sclass_node); end - def parent_module_name_part(node); end - def parenthesized_call?; end - def pin_type?; end - def post_condition_loop?; end - def postexe_type?; end - def preexe_type?; end - def proc?(param0 = nil); end - def procarg0_type?; end - def pure?; end - def range_type?; end - def rational_type?; end - def receiver(param0 = nil); end - def recursive_basic_literal?; end - def recursive_literal?; end - def redo_type?; end - def reference?; end - def regexp_type?; end - def regopt_type?; end - def resbody_type?; end - def rescue_type?; end - def restarg_expr_type?; end - def restarg_type?; end - def retry_type?; end - def return_type?; end - def right_sibling; end - def right_siblings; end - def root?; end - def sclass_type?; end - def self_type?; end - def send_type?; end - def shadowarg_type?; end - def shorthand_asgn?; end - def sibling_index; end - def single_line?; end - def source; end - def source_length; end - def source_range; end - def special_keyword?; end - def splat_type?; end - def str_content(param0 = nil); end - def str_type?; end - def struct_constructor?(param0 = nil); end - def super_type?; end - def sym_type?; end - def true_type?; end - def truthy_literal?; end - def undef_type?; end - def unless_guard_type?; end - def until_post_type?; end - def until_type?; end - def updated(type = nil, children = nil, properties = nil); end - def value_used?; end - def variable?; end - def visit_ancestors(types); end - def when_type?; end - def while_post_type?; end - def while_type?; end - def while_until_value_used?; end - def xstr_type?; end - def yield_type?; end - def zsuper_type?; end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::AST::Descendence - include RuboCop::AST::Sexp -end -module RuboCop::AST::MethodIdentifierPredicates - def assignment_method?; end - def bang_method?; end - def camel_case_method?; end - def comparison_method?; end - def const_receiver?; end - def enumerable_method?; end - def enumerator_method?; end - def method?(name); end - def negation_method?; end - def nonmutating_array_method?; end - def nonmutating_binary_operator_method?; end - def nonmutating_hash_method?; end - def nonmutating_operator_method?; end - def nonmutating_string_method?; end - def nonmutating_unary_operator_method?; end - def operator_method?; end - def predicate_method?; end - def prefix_bang?; end - def prefix_not?; end - def self_receiver?; end -end -module RuboCop::AST::BinaryOperatorNode - def conditions; end - def lhs; end - def rhs; end -end -module RuboCop::AST::CollectionNode - def &(*args, &block); end - def *(*args, &block); end - def +(*args, &block); end - def -(*args, &block); end - def <<(*args, &block); end - def [](*args, &block); end - def []=(*args, &block); end - def all?(*args, &block); end - def any?(*args, &block); end - def append(*args, &block); end - def assoc(*args, &block); end - def at(*args, &block); end - def bsearch(*args, &block); end - def bsearch_index(*args, &block); end - def chain(*args, &block); end - def chunk(*args, &block); end - def chunk_while(*args, &block); end - def clear(*args, &block); end - def collect!(*args, &block); end - def collect(*args, &block); end - def collect_concat(*args, &block); end - def combination(*args, &block); end - def compact!(*args, &block); end - def compact(*args, &block); end - def concat(*args, &block); end - def count(*args, &block); end - def cycle(*args, &block); end - def deconstruct(*args, &block); end - def delete(*args, &block); end - def delete_at(*args, &block); end - def delete_if(*args, &block); end - def detect(*args, &block); end - def difference(*args, &block); end - def dig(*args, &block); end - def drop(*args, &block); end - def drop_while(*args, &block); end - def each(*args, &block); end - def each_cons(*args, &block); end - def each_entry(*args, &block); end - def each_index(*args, &block); end - def each_slice(*args, &block); end - def each_with_index(*args, &block); end - def each_with_object(*args, &block); end - def empty?(*args, &block); end - def entries(*args, &block); end - def fetch(*args, &block); end - def fill(*args, &block); end - def filter!(*args, &block); end - def filter(*args, &block); end - def filter_map(*args, &block); end - def find(*args, &block); end - def find_all(*args, &block); end - def find_index(*args, &block); end - def first(*args, &block); end - def flat_map(*args, &block); end - def flatten!(*args, &block); end - def flatten(*args, &block); end - def grep(*args, &block); end - def grep_v(*args, &block); end - def group_by(*args, &block); end - def include?(*args, &block); end - def index(*args, &block); end - def inject(*args, &block); end - def insert(*args, &block); end - def intersection(*args, &block); end - def join(*args, &block); end - def keep_if(*args, &block); end - def last(*args, &block); end - def lazy(*args, &block); end - def length(*args, &block); end - def map!(*args, &block); end - def map(*args, &block); end - def max(*args, &block); end - def max_by(*args, &block); end - def member?(*args, &block); end - def min(*args, &block); end - def min_by(*args, &block); end - def minmax(*args, &block); end - def minmax_by(*args, &block); end - def none?(*args, &block); end - def one?(*args, &block); end - def pack(*args, &block); end - def partition(*args, &block); end - def permutation(*args, &block); end - def pop(*args, &block); end - def prepend(*args, &block); end - def product(*args, &block); end - def push(*args, &block); end - def rassoc(*args, &block); end - def reduce(*args, &block); end - def reject!(*args, &block); end - def reject(*args, &block); end - def repeated_combination(*args, &block); end - def repeated_permutation(*args, &block); end - def replace(*args, &block); end - def reverse!(*args, &block); end - def reverse(*args, &block); end - def reverse_each(*args, &block); end - def rindex(*args, &block); end - def rotate!(*args, &block); end - def rotate(*args, &block); end - def sample(*args, &block); end - def select!(*args, &block); end - def select(*args, &block); end - def shelljoin(*args, &block); end - def shift(*args, &block); end - def shuffle!(*args, &block); end - def shuffle(*args, &block); end - def size(*args, &block); end - def slice!(*args, &block); end - def slice(*args, &block); end - def slice_after(*args, &block); end - def slice_before(*args, &block); end - def slice_when(*args, &block); end - def sort!(*args, &block); end - def sort(*args, &block); end - def sort_by!(*args, &block); end - def sort_by(*args, &block); end - def sum(*args, &block); end - def take(*args, &block); end - def take_while(*args, &block); end - def tally(*args, &block); end - def to_ary(*args, &block); end - def to_h(*args, &block); end - def to_set(*args, &block); end - def transpose(*args, &block); end - def union(*args, &block); end - def uniq!(*args, &block); end - def uniq(*args, &block); end - def unshift(*args, &block); end - def values_at(*args, &block); end - def zip(*args, &block); end - def |(*args, &block); end - extend Forwardable -end -module RuboCop::AST::ConditionalNode - def body; end - def condition; end - def multiline_condition?; end - def single_line_condition?; end -end -module RuboCop::AST::HashElementNode - def delimiter_delta(other); end - def key; end - def key_delta(other, alignment = nil); end - def same_line?(other); end - def value; end - def value_delta(other); end -end -class RuboCop::AST::HashElementNode::HashElementDelta - def delimiter_delta; end - def delta(first, second, alignment = nil); end - def first; end - def initialize(first, second); end - def key_delta(alignment = nil); end - def keyword_splat?; end - def second; end - def valid_argument_types?; end - def value_delta; end -end -module RuboCop::AST::MethodDispatchNode - def access_modifier?; end - def adjacent_def_modifier?(param0 = nil); end - def arithmetic_operation?; end - def assignment?; end - def bare_access_modifier?; end - def bare_access_modifier_declaration?(param0 = nil); end - def binary_operation?; end - def block_literal?; end - def block_node; end - def command?(name); end - def const_receiver?; end - def def_modifier(node = nil); end - def def_modifier?(node = nil); end - def dot?; end - def double_colon?; end - def implicit_call?; end - def in_macro_scope?(param0 = nil); end - def lambda?; end - def lambda_literal?; end - def macro?; end - def method_name; end - def non_bare_access_modifier?; end - def non_bare_access_modifier_declaration?(param0 = nil); end - def receiver; end - def safe_navigation?; end - def self_receiver?; end - def setter_method?; end - def special_modifier?; end - def unary_operation?; end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::AST::MethodIdentifierPredicates -end -module RuboCop::AST::ModifierNode - def modifier_form?; end -end -module RuboCop::AST::NumericNode - def sign?; end -end -module RuboCop::AST::ParameterizedNode - def arguments?; end - def block_argument?; end - def first_argument; end - def last_argument; end - def parenthesized?; end - def rest_argument?; end - def splat_argument?; end -end -module RuboCop::AST::ParameterizedNode::WrappedArguments - def arguments; end - include RuboCop::AST::ParameterizedNode -end -module RuboCop::AST::ParameterizedNode::RestArguments - def arguments; end - def arguments?; end - def first_argument; end - def last_argument; end - include RuboCop::AST::ParameterizedNode -end -module RuboCop::AST::PredicateOperatorNode - def logical_operator?; end - def operator; end - def semantic_operator?; end -end -module RuboCop::AST::BasicLiteralNode - def value; end -end -class RuboCop::AST::AliasNode < RuboCop::AST::Node - def new_identifier; end - def old_identifier; end -end -class RuboCop::AST::AndNode < RuboCop::AST::Node - def alternate_operator; end - def inverse_operator; end - include RuboCop::AST::BinaryOperatorNode - include RuboCop::AST::PredicateOperatorNode -end -class RuboCop::AST::ArgNode < RuboCop::AST::Node - def default?; end - def default_value; end - def name; end -end -class RuboCop::AST::ArgsNode < RuboCop::AST::Node - def argument_list; end - def empty_and_without_delimiters?; end - include RuboCop::AST::CollectionNode -end -class RuboCop::AST::ArrayNode < RuboCop::AST::Node - def bracketed?; end - def each_value(&block); end - def percent_literal?(type = nil); end - def square_brackets?; end - def values; end -end -class RuboCop::AST::AsgnNode < RuboCop::AST::Node - def expression; end - def name; end -end -class RuboCop::AST::BlockNode < RuboCop::AST::Node - def argument_list; end - def arguments; end - def arguments?; end - def body; end - def braces?; end - def closing_delimiter; end - def delimiters; end - def keywords?; end - def lambda?; end - def method_name; end - def multiline?; end - def numbered_arguments; end - def opening_delimiter; end - def send_node; end - def single_line?; end - def void_context?; end - include RuboCop::AST::MethodIdentifierPredicates -end -class RuboCop::AST::BreakNode < RuboCop::AST::Node - include RuboCop::AST::ParameterizedNode::WrappedArguments -end -class RuboCop::AST::CaseMatchNode < RuboCop::AST::Node - def branches; end - def each_in_pattern(&block); end - def else?; end - def else_branch; end - def in_pattern_branches; end - def keyword; end - include RuboCop::AST::ConditionalNode -end -class RuboCop::AST::CaseNode < RuboCop::AST::Node - def branches; end - def each_when(&block); end - def else?; end - def else_branch; end - def keyword; end - def when_branches; end - include RuboCop::AST::ConditionalNode -end -class RuboCop::AST::CasgnNode < RuboCop::AST::Node - def expression; end - def name; end - def namespace; end -end -class RuboCop::AST::ClassNode < RuboCop::AST::Node - def body; end - def identifier; end - def parent_class; end -end -class RuboCop::AST::ConstNode < RuboCop::AST::Node - def absolute?; end - def class_name?; end - def each_path(&block); end - def module_name?; end - def namespace; end - def relative?; end - def short_name; end -end -class RuboCop::AST::DefNode < RuboCop::AST::Node - def argument_forwarding?; end - def arguments; end - def body; end - def endless?; end - def method_name; end - def receiver; end - def void_context?; end - include RuboCop::AST::MethodIdentifierPredicates - include RuboCop::AST::ParameterizedNode -end -class RuboCop::AST::DefinedNode < RuboCop::AST::Node - def arguments; end - def node_parts; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode -end -class RuboCop::AST::EnsureNode < RuboCop::AST::Node - def body; end -end -class RuboCop::AST::ForNode < RuboCop::AST::Node - def body; end - def collection; end - def do?; end - def keyword; end - def variable; end - def void_context?; end -end -class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node - def to_a; end - include RuboCop::AST::CollectionNode -end -class RuboCop::AST::FloatNode < RuboCop::AST::Node - include RuboCop::AST::BasicLiteralNode - include RuboCop::AST::NumericNode -end -class RuboCop::AST::HashNode < RuboCop::AST::Node - def braces?; end - def each_key(&block); end - def each_pair; end - def each_value(&block); end - def empty?; end - def keys; end - def mixed_delimiters?; end - def pairs; end - def pairs_on_same_line?; end - def values; end -end -class RuboCop::AST::IfNode < RuboCop::AST::Node - def branches; end - def each_branch(&block); end - def else?; end - def else_branch; end - def elsif?; end - def elsif_conditional?; end - def if?; end - def if_branch; end - def inverse_keyword; end - def keyword; end - def modifier_form?; end - def nested_conditional?; end - def node_parts; end - def ternary?; end - def unless?; end - include RuboCop::AST::ConditionalNode - include RuboCop::AST::ModifierNode -end -class RuboCop::AST::InPatternNode < RuboCop::AST::Node - def body; end - def branch_index; end - def pattern; end - def then?; end -end -class RuboCop::AST::IndexNode < RuboCop::AST::Node - def assignment_method?; end - def attribute_accessor?; end - def first_argument_index; end - def method_name; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode::RestArguments -end -class RuboCop::AST::IndexasgnNode < RuboCop::AST::Node - def assignment_method?; end - def attribute_accessor?; end - def first_argument_index; end - def method_name; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode::RestArguments -end -class RuboCop::AST::IntNode < RuboCop::AST::Node - include RuboCop::AST::BasicLiteralNode - include RuboCop::AST::NumericNode -end -class RuboCop::AST::KeywordSplatNode < RuboCop::AST::Node - def colon?; end - def hash_rocket?; end - def node_parts; end - def operator; end - include RuboCop::AST::HashElementNode -end -class RuboCop::AST::LambdaNode < RuboCop::AST::Node - def assignment_method?; end - def attribute_accessor?; end - def first_argument_index; end - def lambda?; end - def lambda_literal?; end - def method_name; end - def receiver; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode::RestArguments -end -class RuboCop::AST::ModuleNode < RuboCop::AST::Node - def body; end - def identifier; end -end -class RuboCop::AST::NextNode < RuboCop::AST::Node - include RuboCop::AST::ParameterizedNode::WrappedArguments -end -class RuboCop::AST::OpAsgnNode < RuboCop::AST::Node - def assignment_node; end - def expression; end - def name; end - def operator; end -end -class RuboCop::AST::AndAsgnNode < RuboCop::AST::OpAsgnNode - def operator; end -end -class RuboCop::AST::OrAsgnNode < RuboCop::AST::OpAsgnNode - def operator; end -end -class RuboCop::AST::OrNode < RuboCop::AST::Node - def alternate_operator; end - def inverse_operator; end - include RuboCop::AST::BinaryOperatorNode - include RuboCop::AST::PredicateOperatorNode -end -class RuboCop::AST::PairNode < RuboCop::AST::Node - def colon?; end - def delimiter(*deprecated, with_spacing: nil); end - def hash_rocket?; end - def inverse_delimiter(*deprecated, with_spacing: nil); end - def value_omission?; end - def value_on_new_line?; end - include RuboCop::AST::HashElementNode -end -class RuboCop::AST::Procarg0Node < RuboCop::AST::ArgNode - def name; end -end -class RuboCop::AST::RangeNode < RuboCop::AST::Node - def begin; end - def end; end -end -class RuboCop::AST::RegexpNode < RuboCop::AST::Node - def content; end - def delimiter?(char); end - def delimiters; end - def extended?; end - def ignore_case?; end - def interpolation?; end - def multiline_mode?; end - def no_encoding?; end - def options; end - def percent_r_literal?; end - def regopt; end - def regopt_include?(option); end - def single_interpolation?; end - def slash_literal?; end - def to_regexp; end -end -class RuboCop::AST::RescueNode < RuboCop::AST::Node - def body; end - def branches; end - def else?; end - def else_branch; end - def resbody_branches; end -end -class RuboCop::AST::ResbodyNode < RuboCop::AST::Node - def body; end - def branch_index; end - def exception_variable; end - def exceptions; end -end -class RuboCop::AST::ReturnNode < RuboCop::AST::Node - include RuboCop::AST::ParameterizedNode::WrappedArguments -end -class RuboCop::AST::SelfClassNode < RuboCop::AST::Node - def body; end - def identifier; end -end -class RuboCop::AST::SendNode < RuboCop::AST::Node - def attribute_accessor?(param0 = nil); end - def first_argument_index; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode::RestArguments -end -class RuboCop::AST::StrNode < RuboCop::AST::Node - def heredoc?; end - include RuboCop::AST::BasicLiteralNode -end -class RuboCop::AST::DstrNode < RuboCop::AST::StrNode - def value; end -end -class RuboCop::AST::SuperNode < RuboCop::AST::Node - def arguments; end - def node_parts; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode -end -class RuboCop::AST::SymbolNode < RuboCop::AST::Node - include RuboCop::AST::BasicLiteralNode -end -class RuboCop::AST::UntilNode < RuboCop::AST::Node - def do?; end - def inverse_keyword; end - def keyword; end - include RuboCop::AST::ConditionalNode - include RuboCop::AST::ModifierNode -end -class RuboCop::AST::WhenNode < RuboCop::AST::Node - def body; end - def branch_index; end - def conditions; end - def each_condition(&block); end - def then?; end -end -class RuboCop::AST::WhileNode < RuboCop::AST::Node - def do?; end - def inverse_keyword; end - def keyword; end - include RuboCop::AST::ConditionalNode - include RuboCop::AST::ModifierNode -end -class RuboCop::AST::YieldNode < RuboCop::AST::Node - def arguments; end - def node_parts; end - include RuboCop::AST::MethodDispatchNode - include RuboCop::AST::ParameterizedNode -end -class RuboCop::AST::Builder < Parser::Builders::Default - def n(type, children, source_map); end - def node_klass(type); end - def string_value(token); end -end -class RuboCop::AST::ProcessedSource - def [](*args); end - def ast; end - def ast_with_comments; end - def blank?; end - def buffer; end - def checksum; end - def comment_at_line(line); end - def comment_index; end - def commented?(source_range); end - def comments; end - def comments_before_line(line); end - def contains_comment?(source_range); end - def create_parser(ruby_version); end - def current_line(token); end - def diagnostics; end - def each_comment(&block); end - def each_comment_in_lines(line_range); end - def each_token(&block); end - def file_path; end - def find_comment(&block); end - def find_token(&block); end - def first_token_index(range_or_node); end - def first_token_of(range_or_node); end - def following_line(token); end - def initialize(source, ruby_version, path = nil); end - def last_token_index(range_or_node); end - def last_token_of(range_or_node); end - def line_indentation(line_number); end - def line_with_comment?(line); end - def lines; end - def parse(source, ruby_version); end - def parser_class(ruby_version); end - def parser_error; end - def path; end - def preceding_line(token); end - def raw_source; end - def ruby_version; end - def self.from_file(path, ruby_version); end - def sorted_tokens; end - def source_range(range_or_node); end - def start_with?(string); end - def tokenize(parser); end - def tokens; end - def tokens_within(range_or_node); end - def valid_syntax?; end -end -module RuboCop::AST::RuboCopCompatibility - def rubocop_loaded; end -end -class RuboCop::AST::Token - def begin_pos; end - def column; end - def comma?; end - def comment?; end - def end?; end - def end_pos; end - def equal_sign?; end - def initialize(pos, type, text); end - def left_array_bracket?; end - def left_brace?; end - def left_bracket?; end - def left_curly_brace?; end - def left_parens?; end - def left_ref_bracket?; end - def line; end - def pos; end - def regexp_dots?; end - def rescue_modifier?; end - def right_bracket?; end - def right_curly_brace?; end - def right_parens?; end - def self.from_parser_token(parser_token); end - def semicolon?; end - def space_after?; end - def space_before?; end - def text; end - def to_s; end - def type; end -end -module RuboCop::AST::Traversal - def on_(node); end - def on___ENCODING__(node); end - def on___FILE__(node); end - def on___LINE__(node); end - def on_alias(node); end - def on_and(node); end - def on_and_asgn(node); end - def on_arg(node); end - def on_arg_expr(node); end - def on_args(node); end - def on_array(node); end - def on_array_pattern(node); end - def on_array_pattern_with_tail(node); end - def on_back_ref(node); end - def on_begin(node); end - def on_block(node); end - def on_block_pass(node); end - def on_blockarg(node); end - def on_break(node); end - def on_case(node); end - def on_case_match(node); end - def on_casgn(node); end - def on_cbase(node); end - def on_class(node); end - def on_complex(node); end - def on_const(node); end - def on_const_pattern(node); end - def on_csend(node); end - def on_cvar(node); end - def on_cvasgn(node); end - def on_def(node); end - def on_defined?(node); end - def on_defs(node); end - def on_dstr(node); end - def on_dsym(node); end - def on_eflipflop(node); end - def on_empty_else(node); end - def on_ensure(node); end - def on_erange(node); end - def on_false(node); end - def on_find_pattern(node); end - def on_float(node); end - def on_for(node); end - def on_forward_arg(node); end - def on_forward_args(node); end - def on_forwarded_args(node); end - def on_gvar(node); end - def on_gvasgn(node); end - def on_hash(node); end - def on_hash_pattern(node); end - def on_if(node); end - def on_if_guard(node); end - def on_iflipflop(node); end - def on_in_match(node); end - def on_in_pattern(node); end - def on_index(node); end - def on_indexasgn(node); end - def on_int(node); end - def on_irange(node); end - def on_ivar(node); end - def on_ivasgn(node); end - def on_kwarg(node); end - def on_kwargs(node); end - def on_kwbegin(node); end - def on_kwnilarg(node); end - def on_kwoptarg(node); end - def on_kwrestarg(node); end - def on_kwsplat(node); end - def on_lambda(node); end - def on_lvar(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_match_alt(node); end - def on_match_as(node); end - def on_match_current_line(node); end - def on_match_nil_pattern(node); end - def on_match_pattern(node); end - def on_match_pattern_p(node); end - def on_match_rest(node); end - def on_match_var(node); end - def on_match_with_lvasgn(node); end - def on_match_with_trailing_comma(node); end - def on_mlhs(node); end - def on_module(node); end - def on_mrasgn(node); end - def on_next(node); end - def on_nil(node); end - def on_not(node); end - def on_nth_ref(node); end - def on_numblock(node); end - def on_op_asgn(node); end - def on_optarg(node); end - def on_or(node); end - def on_or_asgn(node); end - def on_pair(node); end - def on_pin(node); end - def on_postexe(node); end - def on_preexe(node); end - def on_procarg0(node); end - def on_rasgn(node); end - def on_rational(node); end - def on_redo(node); end - def on_regexp(node); end - def on_regopt(node); end - def on_resbody(node); end - def on_rescue(node); end - def on_restarg(node); end - def on_retry(node); end - def on_return(node); end - def on_sclass(node); end - def on_self(node); end - def on_send(node); end - def on_shadowarg(node); end - def on_splat(node); end - def on_str(node); end - def on_super(node); end - def on_sym(node); end - def on_true(node); end - def on_undef(node); end - def on_unless_guard(node); end - def on_until(node); end - def on_until_post(node); end - def on_when(node); end - def on_while(node); end - def on_while_post(node); end - def on_xstr(node); end - def on_yield(node); end - def on_zsuper(node); end - def walk(node); end - extend RuboCop::AST::Traversal::CallbackCompiler -end -class RuboCop::AST::Traversal::DebugError < RuntimeError -end -module RuboCop::AST::Traversal::CallbackCompiler - def arity_check(range); end - def body(signature, prelude); end - def def_callback(type, *signature, arity: nil, arity_check: nil, body: nil); end -end -module RuboCop::AST::Version -end diff --git a/sorbet/rbi/gems/rubocop-ast@1.21.0.rbi b/sorbet/rbi/gems/rubocop-ast@1.21.0.rbi new file mode 100644 index 00000000..29fadc0e --- /dev/null +++ b/sorbet/rbi/gems/rubocop-ast@1.21.0.rbi @@ -0,0 +1,7018 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-ast` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-ast`. + +class Parser::Source::Range + include ::RuboCop::AST::Ext::Range +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range.rb:3 +module RuboCop; end + +# ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range.rb:4 +module RuboCop::AST + extend ::RuboCop::AST::RuboCopCompatibility +end + +# A node extension for `alias` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `alias` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/alias_node.rb:11 +class RuboCop::AST::AliasNode < ::RuboCop::AST::Node + # Returns the new identifier as specified by the `alias`. + # + # @return [SymbolNode] the new identifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/alias_node.rb:19 + def new_identifier; end + + # Returns the old identifier as specified by the `alias`. + # + # @return [SymbolNode] the old identifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/alias_node.rb:12 + def old_identifier; end +end + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/and_asgn_node.rb:11 +class RuboCop::AST::AndAsgnNode < ::RuboCop::AST::OpAsgnNode + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/and_asgn_node.rb:12 + def operator; end +end + +# A node extension for `until` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `until` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/and_node.rb:8 +class RuboCop::AST::AndNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + + # Returns the alternate operator of the `and` as a string. + # Returns `and` for `&&` and vice versa. + # + # @return [String] the alternate of the `and` operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/and_node.rb:16 + def alternate_operator; end + + # Returns the inverse keyword of the `and` node as a string. + # Returns `||` for `&&` and `or` for `and`. + # + # @return [String] the inverse of the `and` operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/and_node.rb:24 + def inverse_operator; end +end + +# A node extension for `arg`, `optarg`, `restarg`, `kwarg`, `kwoptarg`, +# `kwrestarg`, `blockarg`, `shadowarg` and `forward_arg` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all `arg` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/arg_node.rb:12 +class RuboCop::AST::ArgNode < ::RuboCop::AST::Node + # Checks whether the argument has a default value + # + # @return [Boolean] whether the argument has a default value + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/arg_node.rb:29 + def default?; end + + # Returns the default value of the argument, if any. + # + # @return [Node, nil] the default value of the argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/arg_node.rb:20 + def default_value; end + + # Returns the name of an argument. + # + # @return [Symbol, nil] the name of the argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/arg_node.rb:13 + def name; end +end + +# A node extension for `args` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `args` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/args_node.rb:8 +class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node + include ::RuboCop::AST::CollectionNode + + # Yield each argument from the collection. + # Arguments can be inside `mlhs` nodes in the case of destructuring, so this + # flattens the collection to just `arg`, `optarg`, `restarg`, `kwarg`, + # `kwoptarg`, `kwrestarg`, `blockarg`, `forward_arg` and `shadowarg`. + # + # @return [Array<Node>] array of argument nodes. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/args_node.rb:34 + def argument_list; end + + # It returns true if arguments are empty and delimiters do not exist. + # @example: + # # true + # def x; end + # x { } + # -> {} + # + # # false + # def x(); end + # def x a; end + # x { || } + # -> () {} + # -> a {} + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/args_node.rb:24 + def empty_and_without_delimiters?; end +end + +# A node extension for `array` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `array` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:8 +class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node + # Checks whether the `array` literal is delimited by either percent or + # square brackets + # + # brackets + # + # @return [Boolean] whether the array is enclosed in percent or square + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:60 + def bracketed?; end + + # @deprecated Use `values.each` (a.k.a. `children.each`) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:21 + def each_value(&block); end + + # Checks whether the `array` literal is delimited by percent brackets. + # + # @overload percent_literal? + # @overload percent_literal? + # @return [Boolean] whether the array is enclosed in percent brackets + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:47 + def percent_literal?(type = T.unsafe(nil)); end + + # Checks whether the `array` literal is delimited by square brackets. + # + # @return [Boolean] whether the array is enclosed in square brackets + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:32 + def square_brackets?; end + + # Returns an array of all value nodes in the `array` literal. + # + # @return [Array<Node>] an array of value nodes + # + # source://ast-2.4.2/lib/ast/node.rb:56 + def values; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/array_node.rb:9 +RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash) + +# A node extension for `lvasgn`, `ivasgn`, `cvasgn`, and `gvasgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/asgn_node.rb:11 +class RuboCop::AST::AsgnNode < ::RuboCop::AST::Node + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/asgn_node.rb:19 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/asgn_node.rb:12 + def name; end +end + +# Common functionality for primitive literal nodes: `sym`, `str`, +# `int`, `float`, ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/basic_literal_node.rb:7 +module RuboCop::AST::BasicLiteralNode + # Returns the value of the literal. + # + # @return [mixed] the value of the literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/basic_literal_node.rb:11 + def value; end +end + +# Common functionality for nodes that are binary operations: +# `or`, `and` ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/binary_operator_node.rb:7 +module RuboCop::AST::BinaryOperatorNode + # Returns all of the conditions, including nested conditions, + # of the binary operation. + # + # operation and the let and right hand side of any nested binary + # operators + # + # @return [Array<Node>] the left and right hand side of the binary + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/binary_operator_node.rb:28 + def conditions; end + + # Returns the left hand side node of the binary operation. + # + # @return [Node] the left hand side of the binary operation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/binary_operator_node.rb:11 + def lhs; end + + # Returns the right hand side node of the binary operation. + # + # @return [Node] the right hand side of the binary operation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/binary_operator_node.rb:18 + def rhs; end +end + +# A node extension for `block` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `send` nodes within RuboCop. +# +# A `block` node is essentially a method send with a block. Parser nests +# the `send` node inside the `block` node. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:11 +class RuboCop::AST::BlockNode < ::RuboCop::AST::Node + include ::RuboCop::AST::MethodIdentifierPredicates + + # Returns a collection of all descendants of this node that are + # argument type nodes. See `ArgsNode#argument_list` for details. + # + # @return [Array<Node>] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:42 + def argument_list; end + + # The arguments of this block. + # Note that if the block has destructured arguments, `arguments` will + # return a `mlhs` node, whereas `argument_list` will return only + # actual argument nodes. + # + # @return [Array<Node>] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:30 + def arguments; end + + # Checks whether this block takes any arguments. + # + # @return [Boolean] whether this `block` node takes any arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:67 + def arguments?; end + + # The body of this block. + # + # @return [Node, nil] the body of the `block` node or `nil` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:53 + def body; end + + # Checks whether the `block` literal is delimited by curly braces. + # + # @return [Boolean] whether the `block` literal is enclosed in braces + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:74 + def braces?; end + + # The closing delimiter for this `block` literal. + # + # @return [String] the closing delimiter for the `block` literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:102 + def closing_delimiter; end + + # The delimiters for this `block` literal. + # + # @return [Array<String>] the delimiters for the `block` literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:88 + def delimiters; end + + # Checks whether the `block` literal is delimited by `do`-`end` keywords. + # + # @return [Boolean] whether the `block` literal is enclosed in `do`-`end` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:81 + def keywords?; end + + # Checks whether this `block` literal belongs to a lambda. + # + # @return [Boolean] whether the `block` literal belongs to a lambda + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:125 + def lambda?; end + + # The name of the dispatched method as a symbol. + # + # @return [Symbol] the name of the dispatched method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:60 + def method_name; end + + # Checks whether this is a multiline block. This is overridden here + # because the general version in `Node` does not work for `block` nodes. + # + # @return [Boolean] whether the `block` literal is on a several lines + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:118 + def multiline?; end + + # The opening delimiter for this `block` literal. + # + # @return [String] the opening delimiter for the `block` literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:95 + def opening_delimiter; end + + # The `send` node associated with this block. + # + # @return [SendNode] the `send` node associated with the `block` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:20 + def send_node; end + + # Checks whether this is a single line block. This is overridden here + # because the general version in `Node` does not work for `block` nodes. + # + # @return [Boolean] whether the `block` literal is on a single line + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:110 + def single_line?; end + + # Checks whether this node body is a void context. + # + # @return [Boolean] whether the `block` node body is a void context + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:132 + def void_context?; end + + private + + # Numbered arguments of this `numblock`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:139 + def numbered_arguments; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/block_node.rb:14 +RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array) + +# A node extension for `break` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `break` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/break_node.rb:8 +class RuboCop::AST::BreakNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# `RuboCop::AST::Builder` is an AST builder that is utilized to let `Parser` +# generate ASTs with {RuboCop::AST::Node}. +# +# @example +# buffer = Parser::Source::Buffer.new('(string)') +# buffer.source = 'puts :foo' +# +# builder = RuboCop::AST::Builder.new +# require 'parser/ruby25' +# parser = Parser::Ruby25.new(builder) +# root_node = parser.parse(buffer) +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/builder.rb:16 +class RuboCop::AST::Builder < ::Parser::Builders::Default + # Generates {Node} from the given information. + # + # @return [Node] the generated node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/builder.rb:97 + def n(type, children, source_map); end + + # TODO: Figure out what to do about literal encoding handling... + # More details here https://github.com/whitequark/parser/issues/283 + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/builder.rb:103 + def string_value(token); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/builder.rb:109 + def node_klass(type); end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/builder.rb:21 +RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash) + +# A node extension for `case_match` nodes. This will be used in place of +# a plain node when the builder constructs the AST, making its methods +# available to all `case_match` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:8 +class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + + # Returns an array of all the when branches in the `case` statement. + # + # and the `else` (if any). Note that these bodies could be nil. + # + # @return [Array<Node, nil>] an array of the bodies of the `in` branches + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:38 + def branches; end + + # @deprecated Use `in_pattern_branches.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:19 + def each_in_pattern(&block); end + + # Checks whether this case statement has an `else` branch. + # + # @return [Boolean] whether the `case` statement has an `else` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:59 + def else?; end + + # Returns the else branch of the `case` statement, if any. + # + # @return [Node] the else branch node of the `case` statement + # @return [EmptyElse] the empty else branch node of the `case` statement + # @return [nil] if the case statement does not have an else branch. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:52 + def else_branch; end + + # Returns an array of all the `in` pattern branches in the `case` statement. + # + # @return [Array<InPatternNode>] an array of `in_pattern` nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:30 + def in_pattern_branches; end + + # Returns the keyword of the `case` statement as a string. + # + # @return [String] the keyword of the `case` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_match_node.rb:14 + def keyword; end +end + +# A node extension for `case` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `case` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:8 +class RuboCop::AST::CaseNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + + # Returns an array of all the when branches in the `case` statement. + # + # and the else (if any). Note that these bodies could be nil. + # + # @return [Array<Node, nil>] an array of the bodies of the when branches + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:38 + def branches; end + + # @deprecated Use `when_branches.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:19 + def each_when(&block); end + + # Checks whether this case statement has an `else` branch. + # + # @return [Boolean] whether the `case` statement has an `else` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:55 + def else?; end + + # Returns the else branch of the `case` statement, if any. + # + # @return [Node] the else branch node of the `case` statement + # @return [nil] if the case statement does not have an else branch. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:48 + def else_branch; end + + # Returns the keyword of the `case` statement as a string. + # + # @return [String] the keyword of the `case` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:14 + def keyword; end + + # Returns an array of all the when branches in the `case` statement. + # + # @return [Array<WhenNode>] an array of `when` nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/case_node.rb:30 + def when_branches; end +end + +# A node extension for `casgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/casgn_node.rb:11 +class RuboCop::AST::CasgnNode < ::RuboCop::AST::Node + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/casgn_node.rb:26 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/casgn_node.rb:19 + def name; end + + # The namespace of the constant being assigned. + # + # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/casgn_node.rb:12 + def namespace; end +end + +# A node extension for `class` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `class` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/class_node.rb:11 +class RuboCop::AST::ClassNode < ::RuboCop::AST::Node + # The body of this `class` node. + # + # @return [Node, nil] the body of the class + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/class_node.rb:26 + def body; end + + # The identifier for this `class` node. + # + # @return [Node] the identifier of the class + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/class_node.rb:12 + def identifier; end + + # The parent class for this `class` node. + # + # @return [Node, nil] the parent class of the class + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/class_node.rb:19 + def parent_class; end +end + +# A mixin that helps give collection nodes array polymorphism. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/collection_node.rb:6 +module RuboCop::AST::CollectionNode + extend ::Forwardable + + # source://RUBY_ROOT/forwardable.rb:226 + def &(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def *(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def +(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def -(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def <<(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def [](*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def []=(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def all?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def any?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def append(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def assoc(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def at(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def bsearch(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def bsearch_index(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def chain(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def chunk(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def chunk_while(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def clear(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def collect(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def collect!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def collect_concat(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def combination(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def compact(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def compact!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def concat(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def count(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def cycle(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def deconstruct(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def delete(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def delete_at(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def delete_if(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def detect(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def difference(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def dig(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def drop(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def drop_while(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_cons(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_entry(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_index(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_slice(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_with_index(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_with_object(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def empty?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def entries(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def fetch(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def fill(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def filter(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def filter!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def filter_map(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def find(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def find_all(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def find_index(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def first(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def flat_map(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def flatten(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def flatten!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def grep(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def grep_v(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def group_by(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def include?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def index(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def inject(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def insert(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def intersection(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def join(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def keep_if(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def last(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def lazy(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def length(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def map(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def map!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def max(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def max_by(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def member?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def min(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def min_by(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def minmax(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def minmax_by(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def none?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def one?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pack(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def partition(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def permutation(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def place(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def pop(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def prepend(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def product(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def push(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def rassoc(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reduce(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reject(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reject!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def repeated_combination(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def repeated_permutation(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def replace(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reverse(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reverse!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def reverse_each(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def rindex(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def rotate(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def rotate!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sample(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def select(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def select!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def shelljoin(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def shift(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def shuffle(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def shuffle!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def size(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def slice(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def slice!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def slice_after(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def slice_before(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def slice_when(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sort(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sort!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sort_by(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sort_by!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def sum(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def take(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def take_while(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def tally(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_ary(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_h(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_set(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def transpose(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def union(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def uniq(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def uniq!(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def unshift(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def values_at(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def zip(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def |(*args, &block); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/collection_node.rb:9 +RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array) + +# Common functionality for nodes that have conditions: +# `if`, `while`, `until`, `case`. +# This currently doesn't include `when` nodes, because they have multiple +# conditions, and need to be checked for that. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/conditional_node.rb:9 +module RuboCop::AST::ConditionalNode + # Returns the body associated with the condition. This works together with + # each node's custom destructuring method to select the correct part of + # the node. + # + # @note For `if` nodes, this is the truthy branch. + # @return [Node, nil] the body of the node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/conditional_node.rb:40 + def body; end + + # Returns the condition of the node. This works together with each node's + # custom destructuring method to select the correct part of the node. + # + # @return [Node, nil] the condition of the node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/conditional_node.rb:29 + def condition; end + + # Checks whether the condition of the node is written on more than + # one line. + # + # @return [Boolean] whether the condition is on more than one line + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/conditional_node.rb:21 + def multiline_condition?; end + + # Checks whether the condition of the node is written on a single line. + # + # @return [Boolean] whether the condition is on a single line + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/conditional_node.rb:13 + def single_line_condition?; end +end + +# A node extension for `const` nodes. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:7 +class RuboCop::AST::ConstNode < ::RuboCop::AST::Node + # @return [Boolean] if the constant starts with `::` (aka s(:cbase)) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:26 + def absolute?; end + + # @return [Boolean] if the constant is a Module / Class, according to the standard convention. + # Note: some classes might have uppercase in which case this method + # returns false + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:20 + def class_name?; end + + # Yield nodes for the namespace + # + # For `::Foo::Bar::BAZ` => yields: + # s(:cbase), then + # s(:const, :Foo), then + # s(:const, s(:const, :Foo), :Bar) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:43 + def each_path(&block); end + + # @return [Boolean] if the constant is a Module / Class, according to the standard convention. + # Note: some classes might have uppercase in which case this method + # returns false + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:20 + def module_name?; end + + # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:8 + def namespace; end + + # @return [Boolean] if the constant does not start with `::` (aka s(:cbase)) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:33 + def relative?; end + + # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/const_node.rb:13 + def short_name; end +end + +# A node extension for `def` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `def` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:8 +class RuboCop::AST::DefNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + + # Checks whether this method definition node forwards its arguments + # as per the feature added in Ruby 2.7. + # + # @note This is written in a way that may support lead arguments + # which are rumored to be added in a later version of Ruby. + # @return [Boolean] whether the `def` node uses argument forwarding + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:26 + def argument_forwarding?; end + + # An array containing the arguments of the method definition. + # + # @return [Array<Node>] the arguments of the method definition + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:40 + def arguments; end + + # The body of the method definition. + # + # @note this can be either a `begin` node, if the method body contains + # multiple expressions, or any other node, if it contains a single + # expression. + # @return [Node] the body of the method definition + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:51 + def body; end + + # @return [Boolean] if the definition is without an `end` or not. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:63 + def endless?; end + + # The name of the defined method as a symbol. + # + # @return [Symbol] the name of the defined method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:33 + def method_name; end + + # The receiver of the method definition, if any. + # + # @return [Node, nil] the receiver of the method definition, or `nil`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:58 + def receiver; end + + # Checks whether this node body is a void context. + # + # @return [Boolean] whether the `def` node body is a void context + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/def_node.rb:15 + def void_context?; end +end + +# A node extension for `defined?` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `send` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/defined_node.rb:8 +class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast-2.4.2/lib/ast/node.rb:56 + def arguments; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/defined_node.rb:12 + def node_parts; end +end + +# Common functionality for primitive literal nodes: `sym`, `str`, +# `int`, `float`, ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:7 +module RuboCop::AST::Descendence + # Returns an array of child nodes. + # This is a shorthand for `node.each_child_node.to_a`. + # + # @return [Array<Node>] an array of child nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:38 + def child_nodes; end + + # Returns an array of descendant nodes. + # This is a shorthand for `node.each_descendant.to_a`. + # + # @return [Array<Node>] an array of descendant nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:69 + def descendants; end + + # Calls the given block for each child node. + # If no block is given, an `Enumerator` is returned. + # + # Note that this is different from `node.children.each { |child| ... }` + # which yields all children including non-node elements. + # + # @overload each_child_node + # @overload each_child_node + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each child node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:22 + def each_child_node(*types); end + + # Calls the given block for each descendant node with depth first order. + # If no block is given, an `Enumerator` is returned. + # + # @overload each_descendant + # @overload each_descendant + # @overload each_descendant + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each descendant node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:57 + def each_descendant(*types, &block); end + + # Calls the given block for the receiver and each descendant node in + # depth-first order. + # If no block is given, an `Enumerator` is returned. + # + # This method would be useful when you treat the receiver node as the root + # of a tree and want to iterate over all nodes in the tree. + # + # @overload each_node + # @overload each_node + # @overload each_node + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:92 + def each_node(*types, &block); end + + protected + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/descendence.rb:104 + def visit_descendants(types, &block); end +end + +# A node extension for `dstr` nodes. This will be used +# in place of a plain node when the builder constructs the AST, making +# its methods available to all `dstr` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/dstr_node.rb:8 +class RuboCop::AST::DstrNode < ::RuboCop::AST::StrNode + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/dstr_node.rb:9 + def value; end +end + +# A node extension for `ensure` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `ensure` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/ensure_node.rb:11 +class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node + # Returns the body of the `ensure` clause. + # + # @return [Node, nil] The body of the `ensure`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/ensure_node.rb:12 + def body; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range.rb:5 +module RuboCop::AST::Ext; end + +# Extensions to Parser::AST::Range +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range.rb:7 +module RuboCop::AST::Ext::Range + # If `exclude_end` is `true`, then the range will be exclusive. + # + # Assume that `node` corresponds to the following array literal: + # + # [ + # :foo, + # :bar + # ] + # + # node.loc.begin.line_span # => 1..1 + # node.loc.expression.line_span(exclude_end: true) # => 1...4 + # + # @return [Range] the range of line numbers for the node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range.rb:20 + def line_span(exclude_end: T.unsafe(nil)); end +end + +# Refinement to circumvent broken `Range#minmax` for infinity ranges in 2.6- +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/ext/range_min_max.rb:7 +module RuboCop::AST::Ext::RangeMinMax; end + +# A node extension for `float` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available to +# all `float` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/float_node.rb:8 +class RuboCop::AST::FloatNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + include ::RuboCop::AST::NumericNode +end + +# A node extension for `for` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `for` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:11 +class RuboCop::AST::ForNode < ::RuboCop::AST::Node + # Returns the body of the `for` loop. + # + # @return [Node, nil] The body of the `for` loop. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:48 + def body; end + + # Returns the collection the `for` loop is iterating over. + # + # @return [Node] The collection the `for` loop is iterating over + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:41 + def collection; end + + # Checks whether the `for` node has a `do` keyword. + # + # @return [Boolean] whether the `for` node has a `do` keyword + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:19 + def do?; end + + # Returns the keyword of the `for` statement as a string. + # + # @return [String] the keyword of the `until` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:12 + def keyword; end + + # Returns the iteration variable of the `for` loop. + # + # @return [Node] The iteration variable of the `for` loop + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:34 + def variable; end + + # Checks whether this node body is a void context. + # Always `true` for `for`. + # + # @return [true] whether the `for` node body is a void context + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/for_node.rb:27 + def void_context?; end +end + +# A node extension for `forward-args` nodes. This will be used in place +# of a plain node when the builder constructs the AST, making its methods +# available to all `forward-args` nodes within RuboCop. +# +# Not used with modern emitters: +# +# $ ruby-parse -e "def foo(...); end" +# (def :foo +# (args +# (forward-arg)) nil) +# $ ruby-parse --legacy -e "->(foo) { bar }" +# (def :foo +# (forward-args) nil) +# +# Note the extra 's' with legacy form. +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/forward_args_node.rb:23 +class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node + include ::RuboCop::AST::CollectionNode + + # Node wraps itself in an array to be compatible with other + # enumerable argument types. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/forward_args_node.rb:28 + def to_a; end +end + +# Common functionality for nodes that can be used as hash elements: +# `pair`, `kwsplat` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:7 +module RuboCop::AST::HashElementNode + # Returns the delta between this element's delimiter and the argument's. + # + # @note Pairs with different delimiter styles return a delta of 0 + # @return [Integer] the delta between the two delimiters + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:61 + def delimiter_delta(other); end + + # Returns the key of this `hash` element. + # + # @note For keyword splats, this returns the whole node + # @return [Node] the key of the hash element + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:13 + def key; end + + # Returns the delta between this pair's key and the argument pair's. + # + # @note Keys on the same line always return a delta of 0 + # @note Keyword splats always return a delta of 0 for right alignment + # @param alignment [Symbol] whether to check the left or right side + # @return [Integer] the delta between the two keys + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:43 + def key_delta(other, alignment = T.unsafe(nil)); end + + # Checks whether this `hash` element is on the same line as `other`. + # + # @note A multiline element is considered to be on the same line if it + # shares any of its lines with `other` + # @return [Boolean] whether this element is on the same line as `other` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:32 + def same_line?(other); end + + # Returns the value of this `hash` element. + # + # @note For keyword splats, this returns the whole node + # @return [Node] the value of the hash element + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:22 + def value; end + + # Returns the delta between this element's value and the argument's. + # + # @note Keyword splats always return a delta of 0 + # @return [Integer] the delta between the two values + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:52 + def value_delta(other); end +end + +# A helper class for comparing the positions of different parts of a +# `pair` node. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:67 +class RuboCop::AST::HashElementNode::HashElementDelta + # @raise [ArgumentError] + # @return [HashElementDelta] a new instance of HashElementDelta + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:68 + def initialize(first, second); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:89 + def delimiter_delta; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:75 + def key_delta(alignment = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:82 + def value_delta; end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:106 + def delta(first, second, alignment = T.unsafe(nil)); end + + # Returns the value of attribute first. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:98 + def first; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:117 + def keyword_splat?; end + + # Returns the value of attribute second. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:98 + def second; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/hash_element_node.rb:100 + def valid_argument_types?; end +end + +# A node extension for `hash` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `hash` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:14 +class RuboCop::AST::HashNode < ::RuboCop::AST::Node + # Checks whether the `hash` literal is delimited by curly braces. + # + # @return [Boolean] whether the `hash` literal is enclosed in braces + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:117 + def braces?; end + + # Calls the given block for each `key` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:59 + def each_key(&block); end + + # Calls the given block for each `pair` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:33 + def each_pair; end + + # Calls the given block for each `value` node in the `hash` literal. + # If no block is given, an `Enumerator` is returned. + # + # @note `kwsplat` nodes are ignored. + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:83 + def each_value(&block); end + + # Checks whether the `hash` node contains any `pair`- or `kwsplat` nodes. + # + # @return[Boolean] whether the `hash` is empty + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:22 + def empty?; end + + # Returns an array of all the keys in the `hash` literal. + # + # @note `kwsplat` nodes are ignored. + # @return [Array<Node>] an array of keys in the `hash` literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:48 + def keys; end + + # Checks whether this `hash` uses a mix of hash rocket and colon + # delimiters for its pairs. + # + # @note `kwsplat` nodes are ignored. + # @return [Boolean] whether the `hash` uses mixed delimiters + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:110 + def mixed_delimiters?; end + + # Returns an array of all the key value pairs in the `hash` literal. + # + # ignored. + # + # @note this may be different from children as `kwsplat` nodes are + # @return [Array<PairNode>] an array of `pair` nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:15 + def pairs; end + + # Checks whether any of the key value pairs in the `hash` literal are on + # the same line. + # + # @note A multiline `pair` is considered to be on the same line if it + # shares any of its lines with another `pair` + # @note `kwsplat` nodes are ignored. + # @return [Boolean] whether any `pair` nodes are on the same line + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:100 + def pairs_on_same_line?; end + + # Returns an array of all the values in the `hash` literal. + # + # @note `kwsplat` nodes are ignored. + # @return [Array<Node>] an array of values in the `hash` literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/hash_node.rb:72 + def values; end +end + +# A node extension for `if` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `if` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:8 +class RuboCop::AST::IfNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Returns an array of all the branches in the conditional statement. + # + # @return [Array<Node>] an array of branch nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:147 + def branches; end + + # @deprecated Use `branches.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:164 + def each_branch(&block); end + + # Checks whether the `if` node has an `else` clause. + # + # @note This returns `true` for nodes containing an `elsif` clause. + # This is legacy behavior, and many cops rely on it. + # @return [Boolean] whether the node has an `else` clause + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:42 + def else?; end + + # Returns the branch of the `if` node that gets evaluated when its + # condition is falsey. + # + # @note This is normalized for `unless` nodes. + # @return [Node] the falsey branch node of the `if` node + # @return [nil] when there is no else branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:126 + def else_branch; end + + # Checks whether the `if` is an `elsif`. Parser handles these by nesting + # `if` nodes in the `else` branch. + # + # @return [Boolean] whether the node is an `elsif` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:32 + def elsif?; end + + # Checks whether the `if` node has at least one `elsif` branch. Returns + # true if this `if` node itself is an `elsif`. + # + # @return [Boolean] whether the `if` node has at least one `elsif` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:104 + def elsif_conditional?; end + + # Checks whether this node is an `if` statement. (This is not true of + # ternary operators and `unless` statements.) + # + # @return [Boolean] whether the node is an `if` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:16 + def if?; end + + # Returns the branch of the `if` node that gets evaluated when its + # condition is truthy. + # + # @note This is normalized for `unless` nodes. + # @return [Node] the truthy branch node of the `if` node + # @return [nil] if the truthy branch is empty + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:115 + def if_branch; end + + # Returns the inverse keyword of the `if` node as a string. Returns `if` + # for `unless` nodes and vice versa. Returns an empty string for ternary + # operators. + # + # @return [String] the inverse keyword of the `if` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:66 + def inverse_keyword; end + + # Returns the keyword of the `if` statement as a string. Returns an empty + # string for ternary operators. + # + # @return [String] the keyword of the `if` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:57 + def keyword; end + + # Checks whether the `if` node is in a modifier form, i.e. a condition + # trailing behind an expression. Only `if` and `unless` nodes without + # other branches can be modifiers. + # + # @return [Boolean] whether the `if` node is a modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:80 + def modifier_form?; end + + # Chacks whether the `if` node has nested `if` nodes in any of its + # branches. + # + # @note This performs a shallow search. + # @return [Boolean] whether the `if` node contains nested conditionals + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:90 + def nested_conditional?; end + + # Custom destructuring method. This is used to normalize the branches + # for `if` and `unless` nodes, to aid comparisons and conversions. + # + # @return [Array<Node>] the different parts of the `if` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:134 + def node_parts; end + + # Checks whether the `if` node is a ternary operator. + # + # @return [Boolean] whether the `if` node is a ternary operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:49 + def ternary?; end + + # Checks whether this node is an `unless` statement. (This is not true + # of ternary operators and `if` statements.) + # + # @return [Boolean] whether the node is an `unless` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/if_node.rb:24 + def unless?; end +end + +# A node extension for `in` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `in` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/in_pattern_node.rb:11 +class RuboCop::AST::InPatternNode < ::RuboCop::AST::Node + # Returns the body of the `in` node. + # + # @return [Node, nil] the body of the `in` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/in_pattern_node.rb:33 + def body; end + + # Returns the index of the `in` branch within the `case` statement. + # + # @return [Integer] the index of the `in` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/in_pattern_node.rb:19 + def branch_index; end + + # Returns a node of the pattern in the `in` branch. + # + # @return [Node] a pattern node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/in_pattern_node.rb:12 + def pattern; end + + # Checks whether the `in` node has a `then` keyword. + # + # @return [Boolean] whether the `in` node has a `then` keyword + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/in_pattern_node.rb:26 + def then?; end +end + +# Used for modern support only! +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "foo[:bar]" +# (index +# (send nil :foo) +# (sym :bar)) +# $ ruby-parse --legacy -e "foo[:bar]" +# (send +# (send nil :foo) :[] +# (sym :bar)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/index_node.rb:19 +class RuboCop::AST::IndexNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/index_node.rb:29 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/index_node.rb:24 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/index_node.rb:34 + def method_name; end + + private + + # An array containing the arguments of the dispatched method. + # + # @return [Array<Node>] the arguments of the dispatched method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/index_node.rb:43 + def first_argument_index; end +end + +# Used for modern support only! +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "foo[:bar] = :baz" +# (indexasgn +# (send nil :foo) +# (sym :bar) +# (sym :baz)) +# $ ruby-parse --legacy -e "foo[:bar] = :baz" +# (send +# (send nil :foo) :[]= +# (sym :bar) +# (sym :baz)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_index=true` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/indexasgn_node.rb:21 +class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/indexasgn_node.rb:31 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/indexasgn_node.rb:26 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/indexasgn_node.rb:36 + def method_name; end + + private + + # An array containing the arguments of the dispatched method. + # + # @return [Array<Node>] the arguments of the dispatched method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/indexasgn_node.rb:45 + def first_argument_index; end +end + +# A node extension for `int` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available to +# all `int` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/int_node.rb:8 +class RuboCop::AST::IntNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + include ::RuboCop::AST::NumericNode +end + +# A node extension for `kwsplat` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `kwsplat` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:8 +class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node + include ::RuboCop::AST::HashElementNode + + # This is used for duck typing with `pair` nodes which also appear as + # `hash` elements. + # + # @return [false] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:26 + def colon?; end + + # This is used for duck typing with `pair` nodes which also appear as + # `hash` elements. + # + # @return [false] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:18 + def hash_rocket?; end + + # Custom destructuring method. This is used to normalize the branches + # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements. + # + # @return [Array<KeywordSplatNode>] the different parts of the `kwsplat` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:41 + def node_parts; end + + # Returns the operator for the `kwsplat` as a string. + # + # @return [String] the double splat operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:33 + def operator; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/keyword_splat_node.rb:11 +RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String) + +# Used for modern support only: +# Not as thoroughly tested as legacy equivalent +# +# $ ruby-parse -e "->(foo) { bar }" +# (block +# (lambda) +# (args +# (arg :foo)) +# (send nil :bar)) +# $ ruby-parse --legacy -e "->(foo) { bar }" +# (block +# (send nil :lambda) +# (args +# (arg :foo)) +# (send nil :bar)) +# +# The main RuboCop runs in legacy mode; this node is only used +# if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:23 +class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:43 + def assignment_method?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:38 + def attribute_accessor?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:28 + def lambda?; end + + # For similarity with legacy mode + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:33 + def lambda_literal?; end + + # For similarity with legacy mode + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:53 + def method_name; end + + # For similarity with legacy mode + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:48 + def receiver; end + + private + + # For similarity with legacy mode + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/lambda_node.rb:60 + def first_argument_index; end +end + +# Common functionality for nodes that are a kind of method dispatch: +# `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`, +# and (modern only): `index`, `indexasgn`, `lambda` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:8 +module RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + extend ::RuboCop::AST::NodePattern::Macros + + # Checks whether the dispatched method is an access modifier. + # + # @return [Boolean] whether the dispatched method is an access modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:53 + def access_modifier?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:262 + def adjacent_def_modifier?(param0 = T.unsafe(nil)); end + + # Checks whether this node is an arithmetic operation + # + # @return [Boolean] whether the dispatched method is an arithmetic + # operation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:164 + def arithmetic_operation?; end + + # Checks whether the dispatched method is a setter method. + # + # @return [Boolean] whether the dispatched method is a setter + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:96 + def assignment?; end + + # Checks whether the dispatched method is a bare access modifier that + # affects all methods defined after the macro. + # + # @return [Boolean] whether the dispatched method is a bare + # access modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:62 + def bare_access_modifier?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:267 + def bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end + + # Checks whether this is a binary operation. + # + # @example + # + # foo + bar + # @return [Bookean] whether this method is a binary operation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:237 + def binary_operation?; end + + # Whether this method dispatch has an explicit block. + # + # @return [Boolean] whether the dispatched method has a block + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:156 + def block_literal?; end + + # The `block` or `numblock` node associated with this method dispatch, if any. + # + # @return [BlockNode, nil] the `block` or `numblock` node associated with this method + # call or `nil` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:35 + def block_node; end + + # Checks whether the name of the dispatched method matches the argument + # and has an implicit receiver. + # + # @param name [Symbol, String] the method name to check for + # @return [Boolean] whether the method name matches the argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:89 + def command?(name); end + + # Checks whether the *explicit* receiver of this method dispatch is a + # `const` node. + # + # @return [Boolean] whether the receiver of this method dispatch + # is a `const` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:141 + def const_receiver?; end + + # Checks if this node is part of a chain of `def` or `defs` modifiers. + # + # or `nil` if it isn't a def modifier + # + # @example + # + # private def foo; end + # @return [Node | nil] returns the `def|defs` node this is a modifier for, + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:188 + def def_modifier(node = T.unsafe(nil)); end + + # Checks if this node is part of a chain of `def` or `defs` modifiers. + # + # See also `def_modifier` that returns the node or `nil` + # + # @example + # + # private def foo; end + # @return [Boolean] whether the `def|defs` node is a modifier or not. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:176 + def def_modifier?(node = T.unsafe(nil)); end + + # Checks whether the dispatched method uses a dot to connect the + # receiver and the method name. + # + # This is useful for comparison operators, which can be called either + # with or without a dot, i.e. `foo == bar` or `foo.== bar`. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:108 + def dot?; end + + # Checks whether the dispatched method uses a double colon to connect the + # receiver and the method name. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:116 + def double_colon?; end + + # Checks whether the method dispatch is the implicit form of `#call`, + # e.g. `foo.(bar)`. + # + # @return [Boolean] whether the method is the implicit form of `#call` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:149 + def implicit_call?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:246 + def in_macro_scope?(param0 = T.unsafe(nil)); end + + # Checks whether this is a lambda. Some versions of parser parses + # non-literal lambdas as a method send. + # + # @return [Boolean] whether this method is a lambda + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:202 + def lambda?; end + + # Checks whether this is a lambda literal (stabby lambda.) + # + # @example + # + # -> (foo) { bar } + # @return [Boolean] whether this method is a lambda literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:213 + def lambda_literal?; end + + # Checks whether the dispatched method is a macro method. A macro method + # is defined as a method that sits in a class, module, or block body and + # has an implicit receiver. + # + # @note This does not include DSLs that use nested blocks, like RSpec + # @return [Boolean] whether the dispatched method is a macro method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:46 + def macro?; end + + # The name of the dispatched method as a symbol. + # + # @return [Symbol] the name of the dispatched method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:27 + def method_name; end + + # Checks whether the dispatched method is a non-bare access modifier that + # affects only the method it receives. + # + # @return [Boolean] whether the dispatched method is a non-bare + # access modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:71 + def non_bare_access_modifier?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:272 + def non_bare_access_modifier_declaration?(param0 = T.unsafe(nil)); end + + # The receiving node of the method dispatch. + # + # @return [Node, nil] the receiver of the dispatched method or `nil` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:20 + def receiver; end + + # Checks whether the dispatched method uses a safe navigation operator to + # connect the receiver and the method name. + # + # @return [Boolean] whether the method was called with a connecting dot + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:124 + def safe_navigation?; end + + # Checks whether the *explicit* receiver of this method dispatch is + # `self`. + # + # @return [Boolean] whether the receiver of this method dispatch is `self` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:132 + def self_receiver?; end + + # Checks whether the dispatched method is a setter method. + # + # @return [Boolean] whether the dispatched method is a setter + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:96 + def setter_method?; end + + # Checks whether the dispatched method is a bare `private` or `protected` + # access modifier that affects all methods defined after the macro. + # + # @return [Boolean] whether the dispatched method is a bare + # `private` or `protected` access modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:80 + def special_modifier?; end + + # Checks whether this is a unary operation. + # + # @example + # + # -foo + # @return [Boolean] whether this method is a unary operation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:224 + def unary_operation?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:12 +RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_dispatch_node.rb:14 +RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array) + +# Common predicates for nodes that reference method identifiers: +# `send`, `csend`, `def`, `defs`, `super`, `zsuper` +# +# @note this mixin expects `#method_name` and `#receiver` to be implemented +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:9 +module RuboCop::AST::MethodIdentifierPredicates + # Checks whether the method is an assignment method. + # + # @return [Boolean] whether the method is an assignment + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:142 + def assignment_method?; end + + # Checks whether the method is a bang method. + # + # @return [Boolean] whether the method is a bang method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:171 + def bang_method?; end + + # Checks whether the method is a camel case method, + # e.g. `Integer()`. + # + # @return [Boolean] whether the method is a camel case method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:179 + def camel_case_method?; end + + # Checks whether the method is a comparison method. + # + # @return [Boolean] whether the method is a comparison + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:135 + def comparison_method?; end + + # Checks whether the *explicit* receiver of node is a `const` node. + # + # @return [Boolean] whether the receiver of this node is a `const` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:193 + def const_receiver?; end + + # Checks whether the method is an Enumerable method. + # + # @return [Boolean] whether the method is an Enumerable method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:157 + def enumerable_method?; end + + # Checks whether the method is an enumerator method. + # + # @return [Boolean] whether the method is an enumerator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:149 + def enumerator_method?; end + + # Checks whether the method name matches the argument. + # + # @param name [Symbol, String] the method name to check for + # @return [Boolean] whether the method name matches the argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:79 + def method?(name); end + + # Checks whether this is a negation method, i.e. `!` or keyword `not`. + # + # @return [Boolean] whether this method is a negation method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:200 + def negation_method?; end + + # Checks whether the method is a nonmutating Array method. + # + # @return [Boolean] whether the method is a nonmutating Array method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:114 + def nonmutating_array_method?; end + + # Checks whether the method is a nonmutating binary operator method. + # + # @return [Boolean] whether the method is a nonmutating binary operator method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:93 + def nonmutating_binary_operator_method?; end + + # Checks whether the method is a nonmutating Hash method. + # + # @return [Boolean] whether the method is a nonmutating Hash method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:121 + def nonmutating_hash_method?; end + + # Checks whether the method is a nonmutating operator method. + # + # @return [Boolean] whether the method is a nonmutating operator method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:107 + def nonmutating_operator_method?; end + + # Checks whether the method is a nonmutating String method. + # + # @return [Boolean] whether the method is a nonmutating String method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:128 + def nonmutating_string_method?; end + + # Checks whether the method is a nonmutating unary operator method. + # + # @return [Boolean] whether the method is a nonmutating unary operator method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:100 + def nonmutating_unary_operator_method?; end + + # Checks whether the method is an operator method. + # + # @return [Boolean] whether the method is an operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:86 + def operator_method?; end + + # Checks whether the method is a predicate method. + # + # @return [Boolean] whether the method is a predicate method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:164 + def predicate_method?; end + + # Checks whether this is a prefix bang method, e.g. `!foo`. + # + # @return [Boolean] whether this method is a prefix bang + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:214 + def prefix_bang?; end + + # Checks whether this is a prefix not method, e.g. `not foo`. + # + # @return [Boolean] whether this method is a prefix not + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:207 + def prefix_not?; end + + # Checks whether the *explicit* receiver of this node is `self`. + # + # @return [Boolean] whether the receiver of this node is `self` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:186 + def self_receiver?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:16 +RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:10 +RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:32 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:24 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:48 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:28 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:59 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:26 +RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# http://phrogz.net/programmingruby/language.html#table_18.4 +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb:20 +RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set) + +# Common functionality for nodes that can be used as modifiers: +# `if`, `while`, `until` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/modifier_node.rb:7 +module RuboCop::AST::ModifierNode + # Checks whether the node is in a modifier form, i.e. a condition + # trailing behind an expression. + # + # @return [Boolean] whether the node is a modifier + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/modifier_node.rb:12 + def modifier_form?; end +end + +# A node extension for `module` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `module` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/module_node.rb:11 +class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node + # The body of this `module` node. + # + # @return [Node, nil] the body of the module + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/module_node.rb:19 + def body; end + + # The identifier for this `module` node. + # + # @return [Node] the identifier of the module + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/module_node.rb:12 + def identifier; end +end + +# A node extension for `next` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `next` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/next_node.rb:8 +class RuboCop::AST::NextNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# `RuboCop::AST::Node` is a subclass of `Parser::AST::Node`. It provides +# access to parent nodes and an object-oriented way to traverse an AST with +# the power of `Enumerable`. +# +# It has predicate methods for every node type, like this: +# +# @example +# node.send_type? # Equivalent to: `node.type == :send` +# node.op_asgn_type? # Equivalent to: `node.type == :op_asgn` +# +# # Non-word characters (other than a-zA-Z0-9_) in type names are omitted. +# node.defined_type? # Equivalent to: `node.type == :defined?` +# +# # Find the first lvar node under the receiver node. +# lvar_node = node.each_descendant.find(&:lvar_type?) +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:21 +class RuboCop::AST::Node < ::Parser::AST::Node + include ::RuboCop::AST::Sexp + include ::RuboCop::AST::Descendence + extend ::RuboCop::AST::NodePattern::Macros + + # @return [Node] a new instance of Node + # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:88 + def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def __ENCODING___type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def __FILE___type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def __LINE___type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def alias_type?; end + + # Returns an array of ancestor nodes. + # This is a shorthand for `node.each_ancestor.to_a`. + # + # @return [Array<Node>] an array of ancestor nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:237 + def ancestors; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def and_asgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def and_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def arg_expr_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def arg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def args_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:454 + def argument?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:458 + def argument_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def array_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def array_pattern_with_tail_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def array_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:406 + def assignment?; end + + # Some cops treat the shovel operator as a kind of assignment. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:345 + def assignment_or_similar?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def back_ref_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:410 + def basic_conditional?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:353 + def basic_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def begin_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def block_pass_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def block_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def blockarg_expr_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def blockarg_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:462 + def boolean_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def break_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:446 + def call_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def case_match_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def case_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def casgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def cbase_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:450 + def chained?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:502 + def class_constructor?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:514 + def class_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def class_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:132 + def complete!; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:137 + def complete?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def complex_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:414 + def conditional?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:283 + def const_name; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def const_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def const_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def csend_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def cvar_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def cvasgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def def_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:304 + def defined_module; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:309 + def defined_module_name; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def defined_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def defs_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def dstr_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def dsym_type?; end + + # Calls the given block for each ancestor node from parent to root. + # If no block is given, an `Enumerator` is returned. + # + # @overload each_ancestor + # @overload each_ancestor + # @overload each_ancestor + # @return [self] if a block is given + # @return [Enumerator] if no block is given + # @yieldparam node [Node] each ancestor node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:225 + def each_ancestor(*types, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def eflipflop_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def empty_else_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:339 + def empty_source?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def ensure_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:398 + def equals_asgn?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def erange_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def false_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:361 + def falsey_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def find_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:251 + def first_line; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def float_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def for_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def forward_arg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def forward_args_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def forwarded_args_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:499 + def global_const?(param0 = T.unsafe(nil), param1); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:474 + def guard_clause?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def gvar_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def gvasgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def hash_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def hash_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def ident_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def if_guard_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def if_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def iflipflop_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:369 + def immutable_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def in_match_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def in_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def index_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def indexasgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def int_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def irange_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def ivar_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def ivasgn_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:427 + def keyword?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwargs_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwbegin_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwnilarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwoptarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwrestarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def kwsplat_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:493 + def lambda?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:496 + def lambda_or_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def lambda_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:255 + def last_line; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Node, nil] the left (aka previous) sibling + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:175 + def left_sibling; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Array<Node>] the left (aka previous) siblings + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:185 + def left_siblings; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:259 + def line_count; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:349 + def literal?; end + + # NOTE: `loop { }` is a normal method call and thus not a loop keyword. + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:423 + def loop_keyword?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def lvar_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def lvasgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def masgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_alt_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_as_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_current_line_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:481 + def match_guard_clause?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_nil_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_pattern_p_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_pattern_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_rest_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_var_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_with_lvasgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def match_with_trailing_comma_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def mlhs_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:521 + def module_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def module_type?; end + + # Predicates + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:331 + def multiline?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:365 + def mutable_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:655 + def new_class_or_module_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def next_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def nil_type?; end + + # Common destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # Some node types override this with their own custom + # destructuring method. + # + # @return [Array<Node>] the different parts of the ndde + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:206 + def node_parts; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:265 + def nonempty_line_count; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def not_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def nth_ref_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def numargs_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def numblock_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:466 + def numeric_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def objc_kwarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def objc_restarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def objc_varargs_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def op_asgn_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:438 + def operator_keyword?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def optarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def or_asgn_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def or_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def pair_type?; end + + # Returns the parent node, or `nil` if the receiver is a root node. + # + # @return [Node, nil] the parent node or `nil` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:114 + def parent; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:123 + def parent?; end + + # Searching the AST + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:315 + def parent_module_name; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:442 + def parenthesized_call?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def pin_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:418 + def post_condition_loop?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def postexe_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def preexe_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:486 + def proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def procarg0_type?; end + + # Some expressions are evaluated for their value, some for their side + # effects, and some for both. + # If we know that expressions are useful only for their return values, + # and have no side effects, that means we can reorder them, change the + # number of times they are evaluated, or replace them with other + # expressions which are equivalent in value. + # So, is evaluation of this node free of side effects? + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:566 + def pure?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:470 + def range_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def rational_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:276 + def receiver(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:376 + def recursive_basic_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:376 + def recursive_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def redo_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:394 + def reference?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def regexp_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def regopt_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def resbody_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def rescue_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def restarg_expr_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def restarg_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def retry_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def return_type?; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Node, nil] the right (aka next) sibling + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:166 + def right_sibling; end + + # Use is discouraged, this is a potentially slow method and can lead + # to even slower algorithms + # + # @return [Array<Node>] the right (aka next) siblings + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:194 + def right_siblings; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:128 + def root?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def sclass_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def self_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def send_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def shadowarg_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:402 + def shorthand_asgn?; end + + # Returns the index of the receiver node in its siblings. (Sibling index + # uses zero based numbering.) + # Use is discouraged, this is a potentially slow method. + # + # @return [Integer, nil] the index of the receiver node in its siblings + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:159 + def sibling_index; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:335 + def single_line?; end + + # NOTE: Some rare nodes may have no source, like `s(:args)` in `foo {}` + # + # @return [String, nil] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:243 + def source; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:269 + def source_length; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:247 + def source_range; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:434 + def special_keyword?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def splat_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:281 + def str_content(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def str_type?; end + + # @deprecated Use `:class_constructor?` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:509 + def struct_constructor?(param0 = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def super_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def sym_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def true_type?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:357 + def truthy_literal?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def undef_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def unless_guard_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def until_post_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def until_type?; end + + # Override `AST::Node#updated` so that `AST::Processor` does not try to + # mutate our ASTs. Since we keep references from children to parents and + # not just the other way around, we cannot update an AST and share + # identical subtrees. Rather, the entire AST must be copied any time any + # part of it is changed. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:148 + def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end + + # Some expressions are evaluated for their value, some for their side + # effects, and some for both + # If we know that an expression is useful only for its side effects, that + # means we can transform it in ways which preserve the side effects, but + # change the return value + # So, does the return value of this node matter? If we changed it to + # `(...; nil)`, might that affect anything? + # + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:535 + def value_used?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:390 + def variable?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def when_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def while_post_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def while_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def xstr_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def yield_type?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:106 + def zsuper_type?; end + + protected + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:118 + def parent=(node); end + + private + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:594 + def begin_value_used?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:605 + def case_if_value_used?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:295 + def defined_module0(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:599 + def for_value_used?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:641 + def parent_module_name_for_block(ancestor); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:629 + def parent_module_name_for_sclass(sclass_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:616 + def parent_module_name_part(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:584 + def visit_ancestors(types); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:611 + def while_until_value_used?; end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:80 +RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:55 +RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:58 +RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:42 +RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Set) + +# <=> isn't included here, because it doesn't return a boolean. +# +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:28 +RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:39 +RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:60 +RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:50 +RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:35 +RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:47 +RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:70 +RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:37 +RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:83 +RuboCop::AST::Node::LITERAL_RECURSIVE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:84 +RuboCop::AST::Node::LITERAL_RECURSIVE_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:64 +RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:44 +RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:76 +RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:62 +RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:68 +RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:53 +RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:78 +RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:31 +RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node.rb:66 +RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Set) + +# This class performs a pattern-matching operation on an AST node. +# +# Detailed syntax: /docs/modules/ROOT/pages/node_pattern.adoc +# +# Initialize a new `NodePattern` with `NodePattern.new(pattern_string)`, then +# pass an AST node to `NodePattern#match`. Alternatively, use one of the class +# macros in `NodePattern::Macros` to define your own pattern-matching method. +# +# If the match fails, `nil` will be returned. If the match succeeds, the +# return value depends on whether a block was provided to `#match`, and +# whether the pattern contained any "captures" (values which are extracted +# from a matching AST.) +# +# - With block: #match yields the captures (if any) and passes the return +# value of the block through. +# - With no block, but one capture: the capture is returned. +# - With no block, but multiple captures: captures are returned as an array. +# - With no block and no captures: #match returns `true`. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:5 +class RuboCop::AST::NodePattern + include ::RuboCop::AST::NodePattern::MethodDefiner + extend ::Forwardable + + # @return [NodePattern] a new instance of NodePattern + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:61 + def initialize(str, compiler: T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:74 + def ==(other); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:91 + def as_json(_options = T.unsafe(nil)); end + + # Returns the value of attribute ast. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:57 + def ast; end + + # source://RUBY_ROOT/forwardable.rb:226 + def captures(*args, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:95 + def encode_with(coder); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:74 + def eql?(other); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:119 + def freeze; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:99 + def init_with(coder); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:87 + def marshal_dump; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:83 + def marshal_load(pattern); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:69 + def match(*args, **rest, &block); end + + # Returns the value of attribute match_code. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:57 + def match_code; end + + # source://RUBY_ROOT/forwardable.rb:226 + def named_parameters(*args, &block); end + + # Returns the value of attribute pattern. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:57 + def pattern; end + + # source://RUBY_ROOT/forwardable.rb:226 + def positional_parameters(*args, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:79 + def to_s; end + + class << self + # Yields its argument and any descendants, depth-first. + # + # @yield [element] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:105 + def descend(element, &block); end + end +end + +# Responsible to build the AST nodes for `NodePattern` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:10 +class RuboCop::AST::NodePattern::Builder + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:17 + def emit_atom(type, value); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:29 + def emit_call(type, selector, args = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:11 + def emit_capture(capture_token, node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:25 + def emit_list(type, _begin, children, _end); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:41 + def emit_subsequence(node_list); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:21 + def emit_unary_op(type, _operator = T.unsafe(nil), *children); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:34 + def emit_union(begin_t, pattern_lists, end_t); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:53 + def n(type, *args); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:49 + def optimizable_as_set?(children); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/builder.rb:57 + def union_children(pattern_lists); end +end + +# A NodePattern comment, simplified version of ::Parser::Source::Comment +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:7 +class RuboCop::AST::NodePattern::Comment + # @param range [Parser::Source::Range] + # @return [Comment] a new instance of Comment + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:14 + def initialize(range); end + + # Compares comments. Two comments are equal if they + # correspond to the same source range. + # + # @param other [Object] + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:31 + def ==(other); end + + # @return [String] a human-readable representation of this comment + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:39 + def inspect; end + + # Returns the value of attribute location. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:8 + def loc; end + + # Returns the value of attribute location. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:8 + def location; end + + # @return [String] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/comment.rb:20 + def text; end +end + +# The top-level compiler holding the global state +# Defers work to its subcompilers +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:11 +class RuboCop::AST::NodePattern::Compiler + extend ::Forwardable + + # @return [Compiler] a new instance of Compiler + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:15 + def initialize; end + + # source://RUBY_ROOT/forwardable.rb:226 + def bind(*args, &block); end + + # Returns the value of attribute binding. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:13 + def binding; end + + # Returns the value of attribute captures. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:13 + def captures; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:42 + def compile_as_atom(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:46 + def compile_as_node_pattern(node, **options); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:50 + def compile_sequence(sequence, var:); end + + # Enumerates `enum` while keeping track of state across + # union branches (captures and unification). + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:38 + def each_union(enum, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:74 + def freeze; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:31 + def named_parameter(name); end + + # Returns the value of attribute named_parameters. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:13 + def named_parameters; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:70 + def next_capture; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:54 + def parser; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:26 + def positional_parameter(number); end + + # Returns the value of attribute positional_parameters. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:13 + def positional_parameters; end + + # Utilities + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:60 + def with_temp_variables(*names, &block); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:81 + def enforce_same_captures(enum); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler.rb:96 + def new_capture; end +end + +# Generates code that evaluates to a value (Ruby object) +# This value responds to `===`. +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:12 +class RuboCop::AST::NodePattern::Compiler::AtomSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:28 + def visit_const; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:32 + def visit_named_parameter; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:21 + def visit_number; end + + # Assumes other types are node patterns. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:46 + def visit_other_type; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:36 + def visit_positional_parameter; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:21 + def visit_regexp; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:40 + def visit_set; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:21 + def visit_string; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:21 + def visit_symbol; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb:15 + def visit_unify; end +end + +# Holds the list of bound variable names +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/binding.rb:8 +class RuboCop::AST::NodePattern::Compiler::Binding + # @return [Binding] a new instance of Binding + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/binding.rb:9 + def initialize; end + + # Yields the first time a given name is bound + # + # @return [String] bound variable name + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/binding.rb:16 + def bind(name); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/binding.rb:30 + def union_bind(enum); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/binding.rb:69 + def forbid(names); end +end + +# Variant of the Compiler with tracing information for nodes +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:12 +class RuboCop::AST::NodePattern::Compiler::Debug < ::RuboCop::AST::NodePattern::Compiler + # @return [Debug] a new instance of Debug + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:123 + def initialize; end + + # source://RUBY_ROOT/forwardable.rb:226 + def comments(*args, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:128 + def named_parameters; end + + # Returns the value of attribute node_ids. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:33 + def node_ids; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:132 + def parser; end + + # source://RUBY_ROOT/forwardable.rb:226 + def tokens(*args, &block); end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:36 +class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer + # @api private + # @return [Colorizer] a new instance of Colorizer + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:96 + def initialize(pattern, compiler: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:94 + def compiler; end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:94 + def node_pattern; end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:94 + def pattern; end + + # @api private + # @return [Node] the Ruby AST + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:103 + def test(ruby, trace: T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:111 + def ruby_ast(ruby); end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:116 + def ruby_parser; end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:37 +RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::COLOR_SCHEME = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:92 +RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Compiler = RuboCop::AST::NodePattern::Compiler::Debug + +# Result of a NodePattern run against a particular AST +# Consider constructor is private +# +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:46 +class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result < ::Struct + # @api private + # @return [Hash] a map for {character_position => color} + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:56 + def color_map(color_scheme = T.unsafe(nil)); end + + # @api private + # @return [String] a Rainbow colorized version of ruby + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:48 + def colorize(color_scheme = T.unsafe(nil)); end + + # Returns the value of attribute colorizer + # + # @return [Object] the current value of colorizer + def colorizer; end + + # Sets the attribute colorizer + # + # @param value [Object] the value to set the attribute colorizer to. + # @return [Object] the newly set value + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:46 + def colorizer=(_); end + + # @api private + # @return [Hash] a map for {node => matched?}, depth-first + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:66 + def match_map; end + + # @api private + # @return [Boolean] a value of `Trace#matched?` or `:not_visitable` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:74 + def matched?(node); end + + # Returns the value of attribute returned + # + # @return [Object] the current value of returned + def returned; end + + # Sets the attribute returned + # + # @param value [Object] the value to set the attribute returned to. + # @return [Object] the newly set value + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:46 + def returned=(_); end + + # Returns the value of attribute ruby_ast + # + # @return [Object] the current value of ruby_ast + def ruby_ast; end + + # Sets the attribute ruby_ast + # + # @param value [Object] the value to set the attribute ruby_ast to. + # @return [Object] the newly set value + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:46 + def ruby_ast=(_); end + + # Returns the value of attribute trace + # + # @return [Object] the current value of trace + def trace; end + + # Sets the attribute trace + # + # @param value [Object] the value to set the attribute trace to. + # @return [Object] the newly set value + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:46 + def trace=(_); end + + private + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:87 + def ast; end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:81 + def color_map_for(node, color); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:139 +module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:140 + def do_compile; end + + private + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:150 + def node_id; end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:146 + def tracer(kind); end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:156 +class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler + include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:161 +class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler + include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler +end + +# Compiled node pattern requires a named parameter `trace`, +# which should be an instance of this class +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:13 +class RuboCop::AST::NodePattern::Compiler::Debug::Trace + # @return [Trace] a new instance of Trace + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:14 + def initialize; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:18 + def enter(node_id); end + + # return nil (not visited), false (not matched) or true (matched) + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:28 + def matched?(node_id); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/debug.rb:23 + def success(node_id); end +end + +# Compiles code that evalues to true or false +# for a given value `var` (typically a RuboCop::AST::Node) +# or it's `node.type` if `seq_head` is true +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:13 +class RuboCop::AST::NodePattern::Compiler::NodePatternSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + # @return [NodePatternSubcompiler] a new instance of NodePatternSubcompiler + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:16 + def initialize(compiler, var: T.unsafe(nil), access: T.unsafe(nil), seq_head: T.unsafe(nil)); end + + # Returns the value of attribute access. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:14 + def access; end + + # Returns the value of attribute seq_head. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:14 + def seq_head; end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:119 + def access_element; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:123 + def access_node; end + + # @param [Array<Node>, nil] + # @return [String, nil] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:113 + def compile_args(arg_list, first: T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:129 + def compile_guard_clause; end + + # Compiling helpers + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:107 + def compile_value_match(value); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:133 + def multiple_access(kind); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:30 + def visit_ascend; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:58 + def visit_capture; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:37 + def visit_descend; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:84 + def visit_function_call; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:73 + def visit_intersection; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:25 + def visit_negation; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:88 + def visit_node_type; end + + # Assumes other types are atoms. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:100 + def visit_other_type; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:80 + def visit_predicate; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:92 + def visit_sequence; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:49 + def visit_unify; end + + # Lists + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:64 + def visit_union; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/node_pattern_subcompiler.rb:45 + def visit_wildcard; end +end + +# Compiles terms within a sequence to code that evalues to true or false. +# Compilation of the nodes that can match only a single term is deferred to +# `NodePatternSubcompiler`; only nodes that can match multiple terms are +# compiled here. +# Assumes the given `var` is a `::RuboCop::AST::Node` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:17 +class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler < ::RuboCop::AST::NodePattern::Compiler::Subcompiler + # Calls `compile_sequence`; the actual `compile` method + # will be used for the different terms of the sequence. + # The only case of re-entrant call to `compile` is `visit_capture` + # + # @return [SequenceSubcompiler] a new instance of SequenceSubcompiler + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:25 + def initialize(compiler, sequence:, var:); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:31 + def compile_sequence; end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:251 + def in_sync; end + + protected + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:226 + def compile_terms(children = T.unsafe(nil), last_arity = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:251 + def cur_index; end + + # yield `sync_code` iff not already in sync + # + # @yield [code] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:242 + def sync; end + + private + + # Compilation helpers + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:165 + def compile_and_advance(term); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:128 + def compile_any_order_branches(matched_var); end + + # @return [Array<String>] Else code, and init code (if any) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:137 + def compile_any_order_else; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:180 + def compile_captured_repetition(child_code, child_captures); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:119 + def compile_case(when_branches, else_code); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:361 + def compile_child_nb_guard(arity_range); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:319 + def compile_cur_index; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:325 + def compile_index(cur = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:353 + def compile_loop(term); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:347 + def compile_loop_advance(to = T.unsafe(nil)); end + + # Assumes `@cur_index` is already updated + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:198 + def compile_matched(kind); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:304 + def compile_max_matched; end + + # @return [String] code that evaluates to `false` if the matched arity is too small + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:270 + def compile_min_check; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:285 + def compile_remaining; end + + # @return [Hash] of {subcompiler => code} + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:373 + def compile_union_forks; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:313 + def empty_loop; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:214 + def handle_prev; end + + # Modifies in place `forks` + # Syncs our state + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:400 + def merge_forks!(forks); end + + # Modifies in place `forks` to insure that `cur_{child|index}_var` are ok + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:384 + def preserve_union_start(forks); end + + # E.g. For sequence `(_ _? <_ _>)`, arities are: 1, 0..1, 2 + # and remaining arities are: 3..4, 2..3, 2..2, 0..0 + # + # @return [Array<Range>] total arities (as Ranges) of remaining children nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:259 + def remaining_arities(children, last_arity); end + + # returns truthy iff `@cur_index` switched to relative from end mode (i.e. < 0) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:341 + def use_index_from_end; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:88 + def visit_any_order; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:150 + def visit_capture; end + + # Single node patterns are all handled here + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:62 + def visit_other_type; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:78 + def visit_repetition; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:159 + def visit_rest; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:104 + def visit_union; end + + # NOTE: assumes `@cur_index != :seq_head`. Node types using `within_loop` must + # have `def in_sequence_head; :raise; end` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:333 + def within_loop; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:18 +RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::DELTA = T.let(T.unsafe(nil), Integer) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb:19 +RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler::POSITIVE = T.let(T.unsafe(nil), Proc) + +# Base class for subcompilers +# Implements visitor pattern +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:12 +class RuboCop::AST::NodePattern::Compiler::Subcompiler + # @return [Subcompiler] a new instance of Subcompiler + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:15 + def initialize(compiler); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:20 + def compile(node); end + + # Returns the value of attribute compiler. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:13 + def compiler; end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:34 + def do_compile; end + + # Returns the value of attribute node. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:32 + def node; end + + class << self + # @private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:47 + def inherited(base); end + + # @private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:42 + def method_added(method); end + + # Returns the value of attribute registry. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/compiler/subcompiler.rb:40 + def registry; end + end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:53 +class RuboCop::AST::NodePattern::Invalid < ::StandardError; end + +# Lexer class for `NodePattern` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:18 +class RuboCop::AST::NodePattern::Lexer < ::RuboCop::AST::NodePattern::LexerRex + # @return [Lexer] a new instance of Lexer + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:31 + def initialize(source); end + + # Returns the value of attribute comments. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:29 + def comments; end + + # Returns the value of attribute source_buffer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:29 + def source_buffer; end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:29 + def tokens; end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:60 + def do_parse; end + + # @return [token] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:40 + def emit(type); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:48 + def emit_comment; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:52 + def emit_regexp; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:64 + def token(type, value); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:19 +RuboCop::AST::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rb:21 +RuboCop::AST::NodePattern::Lexer::REGEXP_OPTIONS = T.let(T.unsafe(nil), Hash) + +# The generated lexer RuboCop::AST::NodePattern::LexerRex +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:23 +class RuboCop::AST::NodePattern::LexerRex + # Yields on the current action. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:69 + def action; end + + # The file name / path + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:43 + def filename; end + + # The file name / path + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:43 + def filename=(_arg0); end + + # The current location in the parse. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:104 + def location; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:48 + def match; end + + # The match groups for the current scan. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:60 + def matches; end + + # Lex the next token. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:113 + def next_token; end + + # Parse the given string. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:84 + def parse(str); end + + # Read in and parse the file at +path+. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:94 + def parse_file(path); end + + # The current scanner class. Must be overridden in subclasses. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:77 + def scanner_class; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:48 + def ss; end + + # The StringScanner for this lexer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:48 + def ss=(_arg0); end + + # The current lexical state. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:53 + def state; end + + # The current lexical state. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:53 + def state=(_arg0); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:31 +RuboCop::AST::NodePattern::LexerRex::CALL = T.let(T.unsafe(nil), Regexp) + +# :stopdoc: +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:27 +RuboCop::AST::NodePattern::LexerRex::CONST_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:29 +RuboCop::AST::NodePattern::LexerRex::IDENTIFIER = T.let(T.unsafe(nil), Regexp) + +# :startdoc: +# :stopdoc: +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:36 +class RuboCop::AST::NodePattern::LexerRex::LexerError < ::StandardError; end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:30 +RuboCop::AST::NodePattern::LexerRex::NODE_TYPE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:33 +RuboCop::AST::NodePattern::LexerRex::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:32 +RuboCop::AST::NodePattern::LexerRex::REGEXP_BODY = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:28 +RuboCop::AST::NodePattern::LexerRex::SYMBOL_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/lexer.rex.rb:37 +class RuboCop::AST::NodePattern::LexerRex::ScanError < ::RuboCop::AST::NodePattern::LexerRex::LexerError; end + +# Helpers for defining methods based on a pattern string +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:28 +module RuboCop::AST::NodePattern::Macros + # Define a method which applies a pattern to an AST node + # + # The new method will return nil if the node does not match. + # If the node matches, and a block is provided, the new method will + # yield to the block (passing any captures as block arguments). + # If the node matches, and no block is provided, the new method will + # return the captures, or `true` if there were none. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:36 + def def_node_matcher(method_name, pattern_str, **keyword_defaults); end + + # Define a method which recurses over the descendants of an AST node, + # checking whether any of them match the provided pattern + # + # If the method name ends with '?', the new method will return `true` + # as soon as it finds a descendant which matches. Otherwise, it will + # yield all descendants which match. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:46 + def def_node_search(method_name, pattern_str, **keyword_defaults); end +end + +# Functionality to turn `match_code` into methods/lambda +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:7 +module RuboCop::AST::NodePattern::MethodDefiner + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:37 + def as_lambda; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:27 + def compile_as_lambda; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:8 + def def_node_matcher(base, method_name, **defaults); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:21 + def def_node_search(base, method_name, **defaults); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:139 + def compile_init; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:50 + def def_helper(base, method_name, **defaults); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:114 + def emit_keyword_list(forwarding: T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:132 + def emit_lambda_code; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:125 + def emit_method_code; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:63 + def emit_node_search(method_name); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:74 + def emit_node_search_body(method_name, prelude:, on_match:); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:110 + def emit_param_list; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:119 + def emit_params(*first, forwarding: T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:100 + def emit_retval; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:89 + def emit_yield_capture(when_no_capture = T.unsafe(nil), yield_with: T.unsafe(nil)); end + + # This method minimizes the closure for our method + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/method_definer.rb:44 + def wrapping_block(method_name, **defaults); end +end + +# Base class for AST Nodes of a `NodePattern` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:7 +class RuboCop::AST::NodePattern::Node < ::Parser::AST::Node + include ::RuboCop::AST::Descendence + extend ::Forwardable + + # Note: `arity.end` may be `Float::INFINITY` + # + # @return [Integer, Range] An Integer for fixed length terms, otherwise a Range. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:29 + def arity; end + + # @return [Range] arity as a Range + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:69 + def arity_range; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:23 + def capture?; end + + # @return [Node] most nodes have only one child + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:48 + def child; end + + # @return [Array<Node>] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:43 + def children_nodes; end + + # @return [Array<Node>, nil] replace node with result, or `nil` if no change requested. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:34 + def in_sequence_head; end + + # that matches within a Set (e.g. `42`, `:sym` but not `/regexp/`) + # + # @return [Boolean] returns true for nodes having a Ruby literal equivalent + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:64 + def matches_within_set?; end + + # @return [Integer] nb of captures of that node and its descendants + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:53 + def nb_captures; end + + # To be overridden by subclasses + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:19 + def rest?; end + + # @return [Boolean] returns whether it matches a variable number of elements + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:58 + def variadic?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:74 + def with(type: T.unsafe(nil), children: T.unsafe(nil), location: T.unsafe(nil)); end +end + +# Node class for `<int str ...>` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:176 +class RuboCop::AST::NodePattern::Node::AnyOrder < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:194 + def arity; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:186 + def ends_with_rest?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:190 + def rest_node; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:182 + def term_nodes; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:179 +RuboCop::AST::NodePattern::Node::AnyOrder::ARITIES = T.let(T.unsafe(nil), Hash) + +# Node class for `$something` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:94 +class RuboCop::AST::NodePattern::Node::Capture < ::RuboCop::AST::NodePattern::Node + # source://RUBY_ROOT/forwardable.rb:226 + def arity(*args, &block); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:97 + def capture?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:105 + def in_sequence_head; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:101 + def nb_captures; end + + # source://RUBY_ROOT/forwardable.rb:226 + def rest?(*args, &block); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:82 +module RuboCop::AST::NodePattern::Node::ForbidInSeqHead + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:83 + def in_sequence_head; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:136 +RuboCop::AST::NodePattern::Node::FunctionCall = RuboCop::AST::NodePattern::Node::Predicate + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:78 +RuboCop::AST::NodePattern::Node::INT_TO_RANGE = T.let(T.unsafe(nil), Hash) + +# Registry +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:246 +RuboCop::AST::NodePattern::Node::MAP = T.let(T.unsafe(nil), Hash) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:12 +RuboCop::AST::NodePattern::Node::MATCHES_WITHIN_SET = T.let(T.unsafe(nil), Set) + +# Node class for `predicate?(:arg, :list)` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:127 +class RuboCop::AST::NodePattern::Node::Predicate < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:132 + def arg_list; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:128 + def method_name; end +end + +# Node class for `int+` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:139 +class RuboCop::AST::NodePattern::Node::Repetition < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:152 + def arity; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:142 + def operator; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:146 +RuboCop::AST::NodePattern::Node::Repetition::ARITIES = T.let(T.unsafe(nil), Hash) + +# Node class for `...` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:158 +class RuboCop::AST::NodePattern::Node::Rest < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:166 + def arity; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:170 + def in_sequence_head; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:162 + def rest?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:159 +RuboCop::AST::NodePattern::Node::Rest::ARITY = T.let(T.unsafe(nil), Range) + +# Node class for `(type first second ...)` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:114 +class RuboCop::AST::NodePattern::Node::Sequence < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # @return [Sequence] a new instance of Sequence + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:117 + def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end +end + +# A list (potentially empty) of nodes; part of a Union +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:202 +class RuboCop::AST::NodePattern::Node::Subsequence < ::RuboCop::AST::NodePattern::Node + include ::RuboCop::AST::NodePattern::Node::ForbidInSeqHead + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:205 + def arity; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:210 + def in_sequence_head; end +end + +# Node class for `{ ... }` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:220 +class RuboCop::AST::NodePattern::Node::Union < ::RuboCop::AST::NodePattern::Node + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:221 + def arity; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/node.rb:228 + def in_sequence_head; end +end + +# Parser for NodePattern +# Note: class reopened in `parser.racc` +# +# Doc on how this fits in the compiling process: +# /docs/modules/ROOT/pages/node_pattern.adoc +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:13 +class RuboCop::AST::NodePattern::Parser < ::Racc::Parser + extend ::Forwardable + + # @return [Parser] a new instance of Parser + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:19 + def initialize(builder = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:333 + def _reduce_10(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:337 + def _reduce_11(val, _values); end + + # reduce 12 omitted + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:343 + def _reduce_13(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:347 + def _reduce_14(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:351 + def _reduce_15(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:355 + def _reduce_16(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:359 + def _reduce_17(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:363 + def _reduce_18(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:367 + def _reduce_19(val, _values); end + + # reduce 1 omitted + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:301 + def _reduce_2(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:371 + def _reduce_20(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:375 + def _reduce_21(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:379 + def _reduce_22(val, _values); end + + # reduce 24 omitted + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:387 + def _reduce_25(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:393 + def _reduce_26(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:305 + def _reduce_3(val, _values); end + + # reduce 32 omitted + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:413 + def _reduce_33(val, _values); end + + # reduce 36 omitted + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:423 + def _reduce_37(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:427 + def _reduce_38(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:431 + def _reduce_39(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:309 + def _reduce_4(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:435 + def _reduce_40(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:439 + def _reduce_41(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:443 + def _reduce_42(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:447 + def _reduce_43(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:451 + def _reduce_44(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:455 + def _reduce_45(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:459 + def _reduce_46(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:313 + def _reduce_5(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:317 + def _reduce_6(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:321 + def _reduce_7(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:325 + def _reduce_8(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:329 + def _reduce_9(val, _values); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:463 + def _reduce_none(val, _values); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_atom(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_call(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_capture(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_list(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_unary_op(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def emit_union(*args, &block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:40 + def inspect; end + + # source://RUBY_ROOT/forwardable.rb:226 + def next_token(*args, &block); end + + # (Similar API to `parser` gem) + # Parses a source and returns the AST. + # + # @param source_buffer [Parser::Source::Buffer, String] The source buffer to parse. + # @return [NodePattern::Node] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:31 + def parse(source); end + + private + + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:50 + def enforce_unary(node); end + + # Overrides Racc::Parser's method: + # + # @raise [NodePattern::Invalid] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:59 + def on_error(token, val, _vstack); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:16 +RuboCop::AST::NodePattern::Parser::Builder = RuboCop::AST::NodePattern::Builder + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.rb:17 +RuboCop::AST::NodePattern::Parser::Lexer = RuboCop::AST::NodePattern::Lexer + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:227 +RuboCop::AST::NodePattern::Parser::Racc_arg = T.let(T.unsafe(nil), Array) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/parser.racc.rb:243 +RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array) + +# Overrides Parser to use `WithMeta` variants and provide additional methods +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:9 +class RuboCop::AST::NodePattern::Parser::WithMeta < ::RuboCop::AST::NodePattern::Parser + # Returns the value of attribute comments. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:99 + def comments; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:101 + def do_parse; end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:99 + def tokens; end +end + +# Overrides Builder to emit nodes with locations +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:39 +class RuboCop::AST::NodePattern::Parser::WithMeta::Builder < ::RuboCop::AST::NodePattern::Builder + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:40 + def emit_atom(type, token); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:61 + def emit_call(type, selector_t, args = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:55 + def emit_list(type, begin_t, children, end_t); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:49 + def emit_unary_op(type, operator_t = T.unsafe(nil), *children); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:81 + def join_exprs(left_expr, right_expr); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:75 + def loc(token_or_range); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:71 + def n(type, children, source_map); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:86 + def source_map(token_or_range, begin_t: T.unsafe(nil), end_t: T.unsafe(nil), operator_t: T.unsafe(nil), selector_t: T.unsafe(nil)); end +end + +# Overrides Lexer to token locations and comments +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:10 +class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer < ::RuboCop::AST::NodePattern::Lexer + # @return [Lexer] a new instance of Lexer + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:13 + def initialize(str_or_buffer); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:27 + def emit_comment; end + + # @return [::Parser::Source::Range] last match's position + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:33 + def pos; end + + # Returns the value of attribute source_buffer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:11 + def source_buffer; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/with_meta.rb:23 + def token(type, value); end +end + +# Utility to assign a set of values to a constant +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:7 +module RuboCop::AST::NodePattern::Sets + class << self + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:31 + def [](set); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:15 + def name(set); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:22 + def uniq(name); end + end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:14 +RuboCop::AST::NodePattern::Sets::MAX = T.let(T.unsafe(nil), Integer) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:8 +RuboCop::AST::NodePattern::Sets::REGISTRY = T.let(T.unsafe(nil), Hash) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_0_1 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_0_1_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_10_10 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_1_1 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_1_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ALL_CONTEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ANY_ALL_NORETURN_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_BEFORE_AFTER = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_BE_EQ_EQL_EQUAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_BRANCH_REF_TAG = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CALLER_CALLER_LOCATIONS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CALL_RUN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CIPHER_DIGEST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_INSTANCE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CLASS_MODULE_STRUCT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CONSTANTIZE_CONSTANTS_CONST_GET = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_CONTEXT_SHARED_CONTEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_COUNT_LENGTH_SIZE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_DOUBLE_SPY = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_DOWNCASE_UPCASE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EACH_EXAMPLE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_INDEX_WITH_INDEX = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EACH_WITH_OBJECT_WITH_OBJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EQL_EQ_BE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ESCAPE_ENCODE_UNESCAPE_DECODE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EXACTLY_AT_LEAST_AT_MOST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EXIST_EXISTS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_EXPECT_ALLOW = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FACTORYGIRL_FACTORYBOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FILETEST_FILE_DIR_SHELL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FIRST_LAST__ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FIXNUM_BIGNUM = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FLATTEN_FLATTEN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_FORMAT_SPRINTF_PRINTF = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_GSUB_GSUB_SUB_SUB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_INCLUDE_EXTEND_PREPEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_INCLUDE_MEMBER = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_IO_FILE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_IS_EXPECTED_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_KEYS_VALUES = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_KEY_HAS_KEY_FETCH_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_LAST_FIRST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_LENGTH_SIZE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_LOAD_RESTORE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_MAP_COLLECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_MATCH_MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_MATCH__MATCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_NEW_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_NEW_COMPILE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_NEW_OPEN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_NIL_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PRIVATE_PROTECTED_PUBLIC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PROC_LAMBDA = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PROP_CONST = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_ERROR_RAISE_EXCEPTION = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RAISE_FAIL_THROW_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_HAVE_RECEIVED = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_REDUCE_INJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_REJECT_REJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_REQUIRE_REQUIRE_RELATIVE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_FILTER_FIND_ALL_REJECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SELECT_SELECT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SEND_PUBLIC_SEND___SEND__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SHOULD_SHOULD_NOT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SKIP_PENDING = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SORT_BY_SORT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SORT_MIN_MAX = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SPAWN_SYSTEM = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SPRINTF_FORMAT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_START_WITH_END_WITH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_STRUCT_CLASS = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_SUCC_PRED_NEXT = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TASK_NAMESPACE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TEMPFILE_STRINGIO = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TO_ENUM_ENUM_FOR = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TO_H_TO_HASH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TO_I_TO_F_TO_C_TO_R = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TRUE_FALSE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_TYPE_TEMPLATE_TYPE_MEMBER = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_ZERO_POSITIVE_NEGATIVE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__AT_SLICE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__EQL_ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__EQUAL_EQL = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__FETCH = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET__GLOB = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___3 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___4 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___5 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___6 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___7 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___8 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___EQL_ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___EQL_INCLUDE = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET___METHOD_____CALLEE__ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET____ = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET____ETC = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET____ETC_2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET____ETC_3 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern/sets.rb:10 +RuboCop::AST::NodePattern::Sets::SET_____2 = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node_pattern.rb:55 +RuboCop::AST::NodePattern::VAR = T.let(T.unsafe(nil), String) + +# Common functionality for primitive numeric nodes: `int`, `float`, ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/numeric_node.rb:6 +module RuboCop::AST::NumericNode + # Checks whether this is literal has a sign. + # + # @example + # + # +42 + # @return [Boolean] whether this literal has a sign. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/numeric_node.rb:17 + def sign?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/numeric_node.rb:7 +RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp) + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/op_asgn_node.rb:9 +class RuboCop::AST::OpAsgnNode < ::RuboCop::AST::Node + # @return [AsgnNode] the assignment node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/op_asgn_node.rb:10 + def assignment_node; end + + # The expression being assigned to the variable. + # + # @return [Node] the expression being assigned. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/op_asgn_node.rb:31 + def expression; end + + # The name of the variable being assigned as a symbol. + # + # @return [Symbol] the name of the variable being assigned + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/op_asgn_node.rb:17 + def name; end + + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/op_asgn_node.rb:24 + def operator; end +end + +# A node extension for `op_asgn` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all assignment nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/or_asgn_node.rb:11 +class RuboCop::AST::OrAsgnNode < ::RuboCop::AST::OpAsgnNode + # The operator being used for assignment as a symbol. + # + # @return [Symbol] the assignment operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/or_asgn_node.rb:12 + def operator; end +end + +# A node extension for `or` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `or` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/or_node.rb:8 +class RuboCop::AST::OrNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + + # Returns the alternate operator of the `or` as a string. + # Returns `or` for `||` and vice versa. + # + # @return [String] the alternate of the `or` operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/or_node.rb:16 + def alternate_operator; end + + # Returns the inverse keyword of the `or` node as a string. + # Returns `and` for `or` and `&&` for `||`. + # + # @return [String] the inverse of the `or` operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/or_node.rb:24 + def inverse_operator; end +end + +# A node extension for `pair` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `pair` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:8 +class RuboCop::AST::PairNode < ::RuboCop::AST::Node + include ::RuboCop::AST::HashElementNode + + # Checks whether the `pair` uses a colon delimiter. + # + # @return [Boolean] whether this `pair` uses a colon delimiter + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:30 + def colon?; end + + # Returns the delimiter of the `pair` as a string. Returns `=>` for a + # colon delimited `pair` and `:` for a hash rocket delimited `pair`. + # + # @param with_spacing [Boolean] whether to include spacing + # @return [String] the delimiter of the `pair` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:39 + def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end + + # Checks whether the `pair` uses a hash rocket delimiter. + # + # @return [Boolean] whether this `pair` uses a hash rocket delimiter + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:23 + def hash_rocket?; end + + # Returns the inverse delimiter of the `pair` as a string. + # + # @param with_spacing [Boolean] whether to include spacing + # @return [String] the inverse delimiter of the `pair` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:51 + def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end + + # Checks whether the `pair` uses hash value omission. + # + # @return [Boolean] whether this `pair` uses hash value omission + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:69 + def value_omission?; end + + # Checks whether the value starts on its own line. + # + # @return [Boolean] whether the value in the `pair` starts its own line + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:62 + def value_on_new_line?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:15 +RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:11 +RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:17 +RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/pair_node.rb:13 +RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String) + +# Requires implementing `arguments`. +# +# Common functionality for nodes that are parameterized: +# `send`, `super`, `zsuper`, `def`, `defs` +# and (modern only): `index`, `indexasgn`, `lambda` +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:10 +module RuboCop::AST::ParameterizedNode + # Checks whether this node has any arguments. + # + # @return [Boolean] whether this node has any arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:40 + def arguments?; end + + # Whether the last argument of the node is a block pass, + # i.e. `&block`. + # + # @return [Boolean] whether the last argument of the node is a block pass + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:58 + def block_argument?; end + + # A shorthand for getting the first argument of the node. + # Equivalent to `arguments.first`. + # + # @return [Node, nil] the first argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:24 + def first_argument; end + + # A shorthand for getting the last argument of the node. + # Equivalent to `arguments.last`. + # + # @return [Node, nil] the last argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:33 + def last_argument; end + + # Checks whether this node's arguments are wrapped in parentheses. + # + # @return [Boolean] whether this node's arguments are + # wrapped in parentheses + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:15 + def parenthesized?; end + + # Checks whether any argument of the node is a splat + # argument, i.e. `*splat`. + # + # @return [Boolean] whether the node is a splat argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:48 + def rest_argument?; end + + # Checks whether any argument of the node is a splat + # argument, i.e. `*splat`. + # + # @return [Boolean] whether the node is a splat argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:48 + def splat_argument?; end +end + +# A specialized `ParameterizedNode`. +# Requires implementing `first_argument_index` +# Implements `arguments` as `children[first_argument_index..-1]` +# and optimizes other calls +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:83 +module RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::ParameterizedNode + + # @return [Array<Node>] arguments, if any + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:86 + def arguments; end + + # Checks whether this node has any arguments. + # + # @return [Boolean] whether this node has any arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:111 + def arguments?; end + + # A shorthand for getting the first argument of the node. + # Equivalent to `arguments.first`. + # + # @return [Node, nil] the first argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:95 + def first_argument; end + + # A shorthand for getting the last argument of the node. + # Equivalent to `arguments.last`. + # + # @return [Node, nil] the last argument of the node, + # or `nil` if there are no arguments + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:104 + def last_argument; end +end + +# A specialized `ParameterizedNode` for node that have a single child +# containing either `nil`, an argument, or a `begin` node with all the +# arguments +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:66 +module RuboCop::AST::ParameterizedNode::WrappedArguments + include ::RuboCop::AST::ParameterizedNode + + # @return [Array] The arguments of the node. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/parameterized_node.rb:69 + def arguments; end +end + +# Common functionality for nodes that are predicates: +# `or`, `and` ... +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:7 +module RuboCop::AST::PredicateOperatorNode + # Checks whether this is a logical operator. + # + # @return [Boolean] whether this is a logical operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:27 + def logical_operator?; end + + # Returns the operator as a string. + # + # @return [String] the operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:20 + def operator; end + + # Checks whether this is a semantic operator. + # + # @return [Boolean] whether this is a semantic operator + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:34 + def semantic_operator?; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:8 +RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:12 +RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:10 +RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/mixin/predicate_operator_node.rb:14 +RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String) + +# A node extension for `procarg0` nodes. +# This will be used in place of a plain node when the builder constructs +# the AST, making its methods available to all `arg` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/procarg0_node.rb:11 +class RuboCop::AST::Procarg0Node < ::RuboCop::AST::ArgNode + # Returns the name of an argument. + # + # @return [Symbol, nil] the name of the argument + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/procarg0_node.rb:12 + def name; end +end + +# ProcessedSource contains objects which are generated by Parser +# and other information such as disabled lines for cops. +# It also provides a convenient way to access source lines. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:11 +class RuboCop::AST::ProcessedSource + # @return [ProcessedSource] a new instance of ProcessedSource + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:26 + def initialize(source, ruby_version, path = T.unsafe(nil)); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:63 + def [](*args); end + + # Returns the value of attribute ast. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def ast; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:41 + def ast_with_comments; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:102 + def blank?; end + + # Returns the value of attribute buffer. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def buffer; end + + # Raw source checksum for tracking infinite loops. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:74 + def checksum; end + + # @return [Comment, nil] the comment at that line, if any. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:107 + def comment_at_line(line); end + + # Consider using `each_comment_in_lines` instead + # + # @deprecated use contains_comment? + # @return [Boolean] if any of the lines in the given `source_range` has a comment. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:129 + def commented?(source_range); end + + # Returns the value of attribute comments. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def comments; end + + # Should have been called `comments_before_or_at_line`. Doubtful it has of any valid use. + # + # @deprecated Use `each_comment_in_lines` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:137 + def comments_before_line(line); end + + # Consider using `each_comment_in_lines` instead + # + # @return [Boolean] if any of the lines in the given `source_range` has a comment. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:129 + def contains_comment?(source_range); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:151 + def current_line(token); end + + # Returns the value of attribute diagnostics. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def diagnostics; end + + # @deprecated Use `comments.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:79 + def each_comment(&block); end + + # Enumerates on the comments contained with the given `line_range` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:117 + def each_comment_in_lines(line_range); end + + # @deprecated Use `tokens.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:89 + def each_token(&block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:98 + def file_path; end + + # @deprecated Use `comment_at_line`, `each_comment_in_lines`, or `comments.find` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:84 + def find_comment(&block); end + + # @deprecated Use `tokens.find` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:94 + def find_token(&block); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:172 + def first_token_of(range_or_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:155 + def following_line(token); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:176 + def last_token_of(range_or_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:159 + def line_indentation(line_number); end + + # @return [Boolean] if the given line number has a comment. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:112 + def line_with_comment?(line); end + + # Returns the source lines, line break characters removed, excluding a + # possible __END__ and everything that comes after. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:49 + def lines; end + + # Returns the value of attribute parser_error. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def parser_error; end + + # Returns the value of attribute path. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def path; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:147 + def preceding_line(token); end + + # Returns the value of attribute raw_source. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def raw_source; end + + # Returns the value of attribute ruby_version. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def ruby_version; end + + # The tokens list is always sorted by token position, except for cases when heredoc + # is passed as a method argument. In this case tokens are interleaved by + # heredoc contents' tokens. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:183 + def sorted_tokens; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:141 + def start_with?(string); end + + # Returns the value of attribute tokens. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:15 + def tokens; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:166 + def tokens_within(range_or_node); end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:67 + def valid_syntax?; end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:190 + def comment_index; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:275 + def create_parser(ruby_version); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:291 + def first_token_index(range_or_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:296 + def last_token_index(range_or_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:196 + def parse(source, ruby_version); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:230 + def parser_class(ruby_version); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:301 + def source_range(range_or_node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:213 + def tokenize(parser); end + + class << self + # source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:18 + def from_file(path, ruby_version); end + end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:23 +RuboCop::AST::ProcessedSource::INVALID_LEVELS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/processed_source.rb:13 +RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String) + +# A node extension for `irange` and `erange` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its +# methods available to all `irange` and `erange` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/range_node.rb:8 +class RuboCop::AST::RangeNode < ::RuboCop::AST::Node + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/range_node.rb:9 + def begin; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/range_node.rb:13 + def end; end +end + +# A node extension for `regexp` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `regexp` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:8 +class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node + # @return [String] a string of regexp content + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:37 + def content; end + + # @return [Bool] if char is one of the delimiters + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:57 + def delimiter?(char); end + + # @return [String] the regexp delimiters (without %r) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:52 + def delimiters; end + + # @return [Bool] if regexp uses the extended regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:72 + def extended?; end + + # @return [Bool] if regexp uses the fixed-encoding regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:92 + def fixed_encoding?; end + + # @return [Bool] if regexp uses the ignore-case regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:77 + def ignore_case?; end + + # @return [Bool] if regexp contains interpolation + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:62 + def interpolation?; end + + # @return [Bool] if regexp uses the multiline regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:67 + def multiline_mode?; end + + # @return [Bool] if regexp uses the no-encoding regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:87 + def no_encoding?; end + + # NOTE: The 'o' option is ignored. + # + # @return [Integer] the Regexp option bits as returned by Regexp#options + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:32 + def options; end + + # @return [Bool] if the regexp is a %r{...} literal (using any delimiters) + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:47 + def percent_r_literal?; end + + # @return [RuboCop::AST::Node] a regopt node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:25 + def regopt; end + + # @return [Bool] if regexp uses the single-interpolation regopt + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:82 + def single_interpolation?; end + + # @return [Bool] if the regexp is a /.../ literal + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:42 + def slash_literal?; end + + # @return [Regexp] a regexp of this node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:20 + def to_regexp; end + + private + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:98 + def regopt_include?(option); end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/regexp_node.rb:9 +RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash) + +# A node extension for `resbody` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `resbody` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/resbody_node.rb:11 +class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node + # Returns the body of the `rescue` clause. + # + # @return [Node, nil] The body of the `resbody`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/resbody_node.rb:12 + def body; end + + # Returns the index of the `resbody` branch within the exception handling statement. + # + # @return [Integer] the index of the `resbody` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/resbody_node.rb:40 + def branch_index; end + + # Returns the exception variable of the `rescue` clause. + # + # @return [Node, nil] The exception variable of the `resbody`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/resbody_node.rb:33 + def exception_variable; end + + # Returns an array of all the exceptions in the `rescue` clause. + # + # @return [Array<Node>] an array of exception nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/resbody_node.rb:19 + def exceptions; end +end + +# A node extension for `rescue` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `rescue` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:11 +class RuboCop::AST::RescueNode < ::RuboCop::AST::Node + # Returns the body of the rescue node. + # + # @return [Node, nil] The body of the rescue node. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:12 + def body; end + + # Returns an array of all the rescue branches in the exception handling statement. + # + # and the else (if any). Note that these bodies could be nil. + # + # @return [Array<Node, nil>] an array of the bodies of the rescue branches + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:27 + def branches; end + + # Checks whether this exception handling statement has an `else` branch. + # + # @return [Boolean] whether the exception handling statement has an `else` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:44 + def else?; end + + # Returns the else branch of the exception handling statement, if any. + # + # @return [Node] the else branch node of the exception handling statement + # @return [nil] if the exception handling statement does not have an else branch. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:37 + def else_branch; end + + # Returns an array of all the rescue branches in the exception handling statement. + # + # @return [Array<ResbodyNode>] an array of `resbody` nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/rescue_node.rb:19 + def resbody_branches; end +end + +# A node extension for `return` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `return` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/return_node.rb:8 +class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::WrappedArguments +end + +# Responsible for compatibility with main gem +# +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/rubocop_compatibility.rb:8 +module RuboCop::AST::RuboCopCompatibility + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/rubocop_compatibility.rb:13 + def rubocop_loaded; end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/rubocop_compatibility.rb:9 +RuboCop::AST::RuboCopCompatibility::INCOMPATIBLE_COPS = T.let(T.unsafe(nil), Hash) + +# A node extension for `sclass` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `sclass` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/self_class_node.rb:11 +class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node + # The body of this `sclass` node. + # + # @return [Node, nil] the body of the class + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/self_class_node.rb:19 + def body; end + + # The identifier for this `sclass` node. (Always `self`.) + # + # @return [Node] the identifier of the class + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/self_class_node.rb:12 + def identifier; end +end + +# A node extension for `send` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `send` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/send_node.rb:8 +class RuboCop::AST::SendNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::ParameterizedNode::RestArguments + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/send_node.rb:13 + def attribute_accessor?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/send_node.rb:20 + def first_argument_index; end +end + +# This module provides a shorthand method to create a {Node} like +# `Parser::AST::Sexp`. +# +# @see https://www.rubydoc.info/gems/ast/AST/Sexp +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/sexp.rb:9 +module RuboCop::AST::Sexp + # Creates a {Node} with type `type` and children `children`. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/sexp.rb:11 + def s(type, *children); end +end + +# A node extension for `str`, `dstr`, and `xstr` nodes. This will be used +# in place of a plain node when the builder constructs the AST, making +# its methods available to all `str` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/str_node.rb:8 +class RuboCop::AST::StrNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/str_node.rb:11 + def heredoc?; end +end + +# A node extension for `super`- and `zsuper` nodes. This will be used in +# place of a plain node when the builder constructs the AST, making its +# methods available to all `super`- and `zsuper` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/super_node.rb:8 +class RuboCop::AST::SuperNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast-2.4.2/lib/ast/node.rb:56 + def arguments; end + + # Custom destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # + # @return [Array] the different parts of the `super` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/super_node.rb:16 + def node_parts; end +end + +# A node extension for `sym` nodes. This will be used in place of a +# plain node when the builder constructs the AST, making its methods +# available to all `sym` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/symbol_node.rb:8 +class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node + include ::RuboCop::AST::BasicLiteralNode +end + +# A basic wrapper around Parser's tokens. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:6 +class RuboCop::AST::Token + # @return [Token] a new instance of Token + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:15 + def initialize(pos, type, text); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:30 + def begin_pos; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:26 + def column; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:99 + def comma?; end + + # Type Predicates + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:55 + def comment?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:103 + def dot?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:115 + def end?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:34 + def end_pos; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:119 + def equal_sign?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:63 + def left_array_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:79 + def left_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:71 + def left_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:83 + def left_curly_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:91 + def left_parens?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:67 + def left_ref_bracket?; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:22 + def line; end + + # Returns the value of attribute pos. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:7 + def pos; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:107 + def regexp_dots?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:111 + def rescue_modifier?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:75 + def right_bracket?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:87 + def right_curly_brace?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:95 + def right_parens?; end + + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:59 + def semicolon?; end + + # Checks if there is whitespace after token + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:43 + def space_after?; end + + # Checks if there is whitespace before token + # + # @return [Boolean] + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:48 + def space_before?; end + + # Returns the value of attribute text. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:7 + def text; end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:38 + def to_s; end + + # Returns the value of attribute type. + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:7 + def type; end + + class << self + # source://rubocop-ast-1.21.0/lib/rubocop/ast/token.rb:9 + def from_parser_token(parser_token); end + end +end + +# Provides methods for traversing an AST. +# Does not transform an AST; for that, use Parser::AST::Processor. +# Override methods to perform custom processing. Remember to call `super` +# if you want to recursively process descendant nodes. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:9 +module RuboCop::AST::Traversal + extend ::RuboCop::AST::Traversal::CallbackCompiler + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:172 + def on_(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on___ENCODING__(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on___FILE__(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on___LINE__(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_alias(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_and(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_and_asgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_arg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_arg_expr(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_args(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_array(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_array_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_array_pattern_with_tail(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_back_ref(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_begin(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:150 + def on_block(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:128 + def on_block_pass(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_blockarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_break(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_case(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_case_match(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:145 + def on_casgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_cbase(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:146 + def on_class(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_complex(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:144 + def on_const(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_const_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:154 + def on_csend(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_cvar(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:130 + def on_cvasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:147 + def on_def(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_defined?(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:152 + def on_defs(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_dstr(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_dsym(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_eflipflop(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_empty_else(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_ensure(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_erange(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_false(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_find_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_float(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_for(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_forward_arg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_forward_args(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_forwarded_args(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_gvar(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:130 + def on_gvasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_hash(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_hash_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:149 + def on_if(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_if_guard(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_iflipflop(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_in_match(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_in_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_index(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_indexasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_int(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_irange(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_ivar(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:130 + def on_ivasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_kwarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_kwargs(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_kwbegin(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_kwnilarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:131 + def on_kwoptarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:123 + def on_kwrestarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:124 + def on_kwsplat(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_lambda(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_lvar(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:130 + def on_lvasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_masgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_match_alt(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_match_as(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_match_current_line(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_match_nil_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_match_pattern(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_match_pattern_p(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:124 + def on_match_rest(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_match_var(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_match_with_lvasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_match_with_trailing_comma(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_mlhs(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:132 + def on_module(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_mrasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_next(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_nil(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_not(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_nth_ref(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:151 + def on_numblock(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:148 + def on_op_asgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:131 + def on_optarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_or(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_or_asgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_pair(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_pin(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:128 + def on_postexe(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:128 + def on_preexe(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_procarg0(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_rasgn(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_rational(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_redo(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_regexp(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:134 + def on_regopt(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_resbody(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_rescue(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:123 + def on_restarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_retry(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_return(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:132 + def on_sclass(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_self(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:154 + def on_send(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_shadowarg(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:124 + def on_splat(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_str(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_super(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:126 + def on_sym(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_true(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_undef(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:127 + def on_unless_guard(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:132 + def on_until(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_until_post(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:138 + def on_when(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:132 + def on_while(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_while_post(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_xstr(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:135 + def on_yield(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:122 + def on_zsuper(node); end + + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:17 + def walk(node); end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:25 +module RuboCop::AST::Traversal::CallbackCompiler + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:61 + def arity_check(range); end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:52 + def body(signature, prelude); end + + # @api private + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:35 + def def_callback(type, *signature, arity: T.unsafe(nil), arity_check: T.unsafe(nil), body: T.unsafe(nil)); end +end + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:26 +RuboCop::AST::Traversal::CallbackCompiler::SEND = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:29 +RuboCop::AST::Traversal::CallbackCompiler::TEMPLATE = T.let(T.unsafe(nil), Hash) + +# Only for debugging. +# +# @api private +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:12 +class RuboCop::AST::Traversal::DebugError < ::RuntimeError; end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:99 +RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Set) + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/traversal.rb:15 +RuboCop::AST::Traversal::TYPE_TO_METHOD = T.let(T.unsafe(nil), Hash) + +# A node extension for `until` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `until` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/until_node.rb:8 +class RuboCop::AST::UntilNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Checks whether the `until` node has a `do` keyword. + # + # @return [Boolean] whether the `until` node has a `do` keyword + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/until_node.rb:30 + def do?; end + + # Returns the inverse keyword of the `until` node as a string. + # Returns `while` for `until` nodes and vice versa. + # + # @return [String] the inverse keyword of the `until` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/until_node.rb:23 + def inverse_keyword; end + + # Returns the keyword of the `until` statement as a string. + # + # @return [String] the keyword of the `until` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/until_node.rb:15 + def keyword; end +end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/version.rb:5 +module RuboCop::AST::Version; end + +# source://rubocop-ast-1.21.0/lib/rubocop/ast/version.rb:6 +RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String) + +# A node extension for `when` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `when` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:11 +class RuboCop::AST::WhenNode < ::RuboCop::AST::Node + # Returns the body of the `when` node. + # + # @return [Node, nil] the body of the `when` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:42 + def body; end + + # Returns the index of the `when` branch within the `case` statement. + # + # @return [Integer] the index of the `when` branch + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:28 + def branch_index; end + + # Returns an array of all the conditions in the `when` branch. + # + # @return [Array<Node>] an array of condition nodes + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:12 + def conditions; end + + # @deprecated Use `conditions.each` + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:17 + def each_condition(&block); end + + # Checks whether the `when` node has a `then` keyword. + # + # @return [Boolean] whether the `when` node has a `then` keyword + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/when_node.rb:35 + def then?; end +end + +# A node extension for `while` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `while` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/while_node.rb:8 +class RuboCop::AST::WhileNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + + # Checks whether the `until` node has a `do` keyword. + # + # @return [Boolean] whether the `until` node has a `do` keyword + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/while_node.rb:30 + def do?; end + + # Returns the inverse keyword of the `while` node as a string. + # Returns `until` for `while` nodes and vice versa. + # + # @return [String] the inverse keyword of the `while` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/while_node.rb:23 + def inverse_keyword; end + + # Returns the keyword of the `while` statement as a string. + # + # @return [String] the keyword of the `while` statement + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/while_node.rb:15 + def keyword; end +end + +# A node extension for `yield` nodes. This will be used in place of a plain +# node when the builder constructs the AST, making its methods available +# to all `yield` nodes within RuboCop. +# +# source://rubocop-ast-1.21.0/lib/rubocop/ast/node/yield_node.rb:8 +class RuboCop::AST::YieldNode < ::RuboCop::AST::Node + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::MethodDispatchNode + + # source://ast-2.4.2/lib/ast/node.rb:56 + def arguments; end + + # Custom destructuring method. This can be used to normalize + # destructuring for different variations of the node. + # + # @return [Array] the different parts of the `send` node + # + # source://rubocop-ast-1.21.0/lib/rubocop/ast/node/yield_node.rb:16 + def node_parts; end +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token diff --git a/sorbet/rbi/gems/rubocop-performance.rbi b/sorbet/rbi/gems/rubocop-performance.rbi deleted file mode 100644 index 912b8d50..00000000 --- a/sorbet/rbi/gems/rubocop-performance.rbi +++ /dev/null @@ -1,522 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-performance/all/rubocop-performance.rbi -# -# rubocop-performance-1.14.3 - -module RuboCop -end -module RuboCop::Performance -end -module RuboCop::Performance::Version - def self.document_version; end -end -module RuboCop::Performance::Inject - def self.defaults!; end -end -module RuboCop::Cop -end -module RuboCop::Cop::RegexpMetacharacter - def drop_end_metacharacter(regexp_string); end - def drop_start_metacharacter(regexp_string); end - def literal_at_end?(regexp); end - def literal_at_end_with_backslash_z?(regex_str); end - def literal_at_end_with_dollar?(regex_str); end - def literal_at_start?(regexp); end - def literal_at_start_with_backslash_a?(regex_str); end - def literal_at_start_with_caret?(regex_str); end - def safe_multiline?; end -end -module RuboCop::Cop::SortBlock - def replaceable_body?(param0 = nil, param1, param2); end - def sort_range(send, node); end - def sort_with_block?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::Performance -end -class RuboCop::Cop::Performance::AncestorsInclude < RuboCop::Cop::Base - def ancestors_include_candidate?(param0 = nil); end - def on_send(node); end - def range(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice < RuboCop::Cop::Base - def correction(receiver, range_node); end - def endless_range?(param0 = nil); end - def endless_range_slice?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < RuboCop::Cop::Base - def big_decimal_with_numeric_argument?(param0 = nil); end - def on_send(node); end - def to_d?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::BindCall < RuboCop::Cop::Base - def bind_with_call_method?(param0 = nil); end - def build_call_args(call_args_node); end - def correction_range(receiver, node); end - def message(bind_arg, call_args); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock < RuboCop::Cop::Base - def on_send(node); end - def reassigns_block_arg?(param0 = nil, param1); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::Caller < RuboCop::Cop::Base - def caller_with_scope_method?(param0 = nil); end - def int_value(node); end - def on_send(node); end - def slow_caller?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::CaseWhenSplat < RuboCop::Cop::Base - def autocorrect(corrector, when_node); end - def indent_for(node); end - def inline_fix_branch(corrector, when_node); end - def needs_reorder?(when_node); end - def new_branch_without_then(node, new_condition); end - def new_condition_with_then(node, new_condition); end - def non_splat?(condition); end - def on_case(case_node); end - def range(node); end - def reorder_condition(corrector, when_node); end - def reordering_correction(when_node); end - def replacement(conditions); end - def splat_offenses(when_conditions); end - def when_branch_range(when_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::Casecmp < RuboCop::Cop::Base - def autocorrect(corrector, node, replacement); end - def build_good_method(method, arg, variable); end - def downcase_downcase(param0 = nil); end - def downcase_eq(param0 = nil); end - def eq_downcase(param0 = nil); end - def on_send(node); end - def take_method_apart(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::CollectionLiteralInLoop < RuboCop::Cop::Base - def check_literal?(node, method); end - def enumerable_loop?(param0 = nil); end - def enumerable_method?(method_name); end - def kernel_loop?(param0 = nil); end - def keyword_loop?(type); end - def literal_class(node); end - def loop?(ancestor, node); end - def min_size; end - def node_within_enumerable_loop?(node, ancestor); end - def nonmutable_method_of_array_or_hash?(node, method); end - def on_send(node); end - def parent_is_loop?(node); end -end -class RuboCop::Cop::Performance::CompareWithBlock < RuboCop::Cop::Base - def compare?(param0 = nil); end - def compare_range(send, node); end - def message(send, method, var_a, var_b, args); end - def on_block(node); end - def replaceable_body?(param0 = nil, param1, param2); end - def slow_compare?(method, args_a, args_b); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::ConcurrentMonotonicTime < RuboCop::Cop::Base - def concurrent_monotonic_time?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::ConstantRegexp < RuboCop::Cop::Base - def include_interpolated_const?(node); end - def on_regexp(node); end - def regexp_escape?(param0 = nil); end - def within_allowed_assignment?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::Count < RuboCop::Cop::Base - def autocorrect(corrector, node, selector_node, selector); end - def count_candidate?(param0 = nil); end - def eligible_node?(node); end - def on_send(node); end - def source_starting_at(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::DeletePrefix < RuboCop::Cop::Base - def delete_prefix_candidate?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RegexpMetacharacter -end -class RuboCop::Cop::Performance::DeleteSuffix < RuboCop::Cop::Base - def delete_suffix_candidate?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RegexpMetacharacter -end -class RuboCop::Cop::Performance::Detect < RuboCop::Cop::Base - def accept_first_call?(receiver, body); end - def autocorrect(corrector, node, replacement); end - def detect_candidate?(param0 = nil); end - def lazy?(node); end - def message_for_method(method, index); end - def on_send(node); end - def preferred_method; end - def register_offense(node, receiver, second_method, index); end - def replacement(method, index); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::DoubleStartEndWith < RuboCop::Cop::Base - def autocorrect(corrector, first_call_args, second_call_args, combined_args); end - def check_for_active_support_aliases?; end - def check_with_active_support_aliases(param0 = nil); end - def combine_args(first_call_args, second_call_args); end - def message(node, receiver, method, combined_args); end - def on_or(node); end - def process_source(node); end - def two_start_end_with_calls(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::EndWith < RuboCop::Cop::Base - def on_match_with_lvasgn(node); end - def on_send(node); end - def redundant_regex?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RegexpMetacharacter -end -class RuboCop::Cop::Performance::FixedSize < RuboCop::Cop::Base - def allowed_argument?(arg); end - def allowed_parent?(node); end - def allowed_variable?(var); end - def contains_double_splat?(node); end - def contains_splat?(node); end - def counter(param0 = nil); end - def non_string_argument?(node); end - def on_send(node); end -end -class RuboCop::Cop::Performance::FlatMap < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def flat_map_candidate?(param0 = nil); end - def offense_for_levels(node, map_node, first_method, flatten); end - def offense_for_method(node, map_node, first_method, flatten); end - def on_send(node); end - def register_offense(node, map_node, first_method, flatten, message); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::InefficientHashSearch < RuboCop::Cop::Base - def autocorrect_argument(node); end - def autocorrect_hash_expression(node); end - def autocorrect_method(node); end - def current_method(node); end - def inefficient_include?(param0 = nil); end - def message(node); end - def on_send(node); end - def use_long_method; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::MapCompact < RuboCop::Cop::Base - def compact_method_with_final_newline_range(compact_method_range); end - def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method); end - def map_compact(param0 = nil); end - def map_method_and_compact_method_on_same_line?(map_node, compact_node); end - def on_send(node); end - def remove_compact_method(corrector, map_node, compact_node, chained_method); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::MethodObjectAsBlock < RuboCop::Cop::Base - def method_object_as_argument?(param0 = nil); end - def on_block_pass(node); end -end -class RuboCop::Cop::Performance::OpenStruct < RuboCop::Cop::Base - def on_send(node); end - def open_struct(param0 = nil); end -end -class RuboCop::Cop::Performance::RangeInclude < RuboCop::Cop::Base - def on_send(node); end - def range_include(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::IoReadlines < RuboCop::Cop::Base - def autocorrect(corrector, enumerable_call, readlines_call, receiver); end - def build_bad_method(enumerable_call); end - def build_call_args(call_args_node); end - def build_good_method(enumerable_call); end - def correction_range(enumerable_call, readlines_call); end - def offense_range(enumerable_call, readlines_call); end - def on_send(node); end - def readlines_on_class?(param0 = nil); end - def readlines_on_instance?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::RedundantBlockCall < RuboCop::Cop::Base - def args_include_block_pass?(blockcall); end - def autocorrect(corrector, node); end - def blockarg_assigned?(param0, param1); end - def blockarg_calls(param0, param1); end - def blockarg_def(param0 = nil); end - def calls_to_report(argname, body); end - def on_def(node); end - def on_defs(node); end - def shadowed_block_argument?(body, block_argument_of_method_signature); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock < RuboCop::Cop::Base - def new_argument(block_argument, block_body); end - def offense_range(node); end - def on_block(node); end - def one_block_argument?(block_arguments); end - def same_block_argument_and_is_a_argument?(block_body, block_argument); end - def use_block_argument_in_method_argument_of_operand?(block_argument, operand); end - def use_equality_comparison_block?(block_body); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Performance::RedundantMatch < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def match_call?(param0 = nil); end - def on_send(node); end - def only_truthiness_matters?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::RedundantMerge < RuboCop::Cop::Base - def correct_multiple_elements(corrector, node, parent, new_source); end - def correct_single_element(corrector, node, new_source); end - def each_redundant_merge(node); end - def indent_width; end - def kwsplat_used?(pairs); end - def leading_spaces(node); end - def max_key_value_pairs; end - def message(node); end - def modifier_flow_control?(param0 = nil); end - def non_redundant_merge?(node, receiver, pairs); end - def non_redundant_pairs?(receiver, pairs); end - def non_redundant_value_used?(receiver, node); end - def on_send(node); end - def redundant_merge_candidate(param0 = nil); end - def rewrite_with_modifier(node, parent, new_source); end - def to_assignments(receiver, pairs); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector - def each_with_object_node(param0 = nil); end - def eligible_receiver?; end - def initialize(node, receiver); end - def node; end - def receiver; end - def second_argument; end - def unwind(receiver); end - def value_used?; end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::Performance::RedundantSortBlock < RuboCop::Cop::Base - def message(var_a, var_b); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SortBlock -end -class RuboCop::Cop::Performance::RedundantSplitRegexpArgument < RuboCop::Cop::Base - def determinist_regexp?(regexp_node); end - def on_send(node); end - def replacement(regexp_node); end - def split_call_with_regexp?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::RedundantStringChars < RuboCop::Cop::Base - def build_bad_method(method, args); end - def build_call_args(call_args_node); end - def build_good_method(method, args); end - def build_good_method_for_brackets_or_first_method(method, args); end - def build_message(method, args); end - def correction_range(receiver, node); end - def offense_range(receiver, node); end - def on_send(node); end - def redundant_chars_call?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::RegexpMatch < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check_condition(cond); end - def correct_operator(corrector, recv, arg, oper = nil); end - def correction_range(recv, arg); end - def find_last_match(body, range, scope_root); end - def last_match_used?(match_node); end - def last_matches(param0); end - def match_gvar?(sym); end - def match_method?(param0 = nil); end - def match_node?(param0 = nil); end - def match_operator?(param0 = nil); end - def match_threequals?(param0 = nil); end - def match_with_int_arg_method?(param0 = nil); end - def match_with_lvasgn?(node); end - def message(node); end - def modifier_form?(match_node); end - def next_match_pos(body, match_node_pos, scope_root); end - def on_case(node); end - def on_if(node); end - def range_to_search_for_last_matches(match_node, body, scope_root); end - def replace_with_match_predicate_method(corrector, recv, arg, op_range); end - def scope_body(node); end - def scope_root(node); end - def search_match_nodes(param0); end - def swap_receiver_and_arg(corrector, recv, arg); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Performance::ReverseEach < RuboCop::Cop::Base - def offense_range(node); end - def on_send(node); end - def reverse_each?(param0 = nil); end - def use_return_value?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::ReverseFirst < RuboCop::Cop::Base - def build_bad_method(node); end - def build_good_method(node); end - def build_message(node); end - def correction_range(receiver, node); end - def on_send(node); end - def reverse_first_candidate?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::SelectMap < RuboCop::Cop::Base - def bad_method?(param0 = nil); end - def map_method_candidate(node); end - def offense_range(node, map_method); end - def on_send(node); end - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::Size < RuboCop::Cop::Base - def array?(param0 = nil); end - def count?(param0 = nil); end - def hash?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::SortReverse < RuboCop::Cop::Base - def message(var_a, var_b); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SortBlock -end -class RuboCop::Cop::Performance::Squeeze < RuboCop::Cop::Base - def on_send(node); end - def repeating_literal?(regex_str); end - def squeeze_candidate?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::StartWith < RuboCop::Cop::Base - def on_match_with_lvasgn(node); end - def on_send(node); end - def redundant_regex?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RegexpMetacharacter -end -class RuboCop::Cop::Performance::StringIdentifierArgument < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::StringInclude < RuboCop::Cop::Base - def literal?(regex_str); end - def on_match_with_lvasgn(node); end - def on_send(node); end - def redundant_regex?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::StringReplacement < RuboCop::Cop::Base - def accept_first_param?(first_param); end - def accept_second_param?(second_param); end - def autocorrect(corrector, node); end - def first_source(first_param); end - def message(node, first_source, second_source); end - def method_suffix(node); end - def offense(node, first_param, second_param); end - def on_send(node); end - def range(node); end - def remove_second_param(corrector, node, first_param); end - def replace_method(corrector, node, first_source, second_source, first_param); end - def replacement_method(node, first_source, second_source); end - def source_from_regex_constructor(node); end - def source_from_regex_literal(node); end - def string_replacement?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::Sum < RuboCop::Cop::Base - def acc_plus_elem?(param0 = nil, param1, param2); end - def array_literal?(node); end - def autocorrect(corrector, init, range); end - def autocorrect_sum_map(corrector, sum, map, init); end - def build_block_bad_method(method, init, var_acc, var_elem, body); end - def build_block_message(send, init, var_acc, var_elem, body); end - def build_good_method(init, block_pass = nil); end - def build_method_bad_method(init, method, operation); end - def build_method_message(node, method, init, operation); end - def build_sum_map_message(method, init); end - def elem_plus_acc?(param0 = nil, param1, param2); end - def empty_array_literal?(node); end - def handle_sum_candidate(node); end - def handle_sum_map_candidate(node); end - def method_call_with_args_range(node); end - def on_block(node); end - def on_send(node); end - def sum_block_range(send, node); end - def sum_candidate?(param0 = nil); end - def sum_map_candidate?(param0 = nil); end - def sum_map_range(map, sum); end - def sum_method_range(node); end - def sum_with_block_candidate?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Performance::TimesMap < RuboCop::Cop::Base - def check(node); end - def message(map_or_collect, count); end - def on_block(node); end - def on_send(node); end - def times_map_call(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::UnfreezeString < RuboCop::Cop::Base - def dup_string?(param0 = nil); end - def on_send(node); end - def string_new?(param0 = nil); end - def string_value(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::UriDefaultParser < RuboCop::Cop::Base - def on_send(node); end - def uri_parser_new?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Performance::ChainArrayAllocation < RuboCop::Cop::Base - def chain_array_allocation?(param0 = nil); end - def on_send(node); end - include RuboCop::Cop::RangeHelp -end diff --git a/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi b/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi new file mode 100644 index 00000000..24da36b0 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-performance@1.14.3.rbi @@ -0,0 +1,2986 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-performance` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-performance`. + +# source://rubocop-performance-1.14.3/lib/rubocop/performance.rb:3 +module RuboCop; end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:4 +module RuboCop::Cop; end + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:33 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:46 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:5 +module RuboCop::Cop::Performance; end + +# Identifies usages of `ancestors.include?` and change them to use `<=` instead. +# +# @example +# # bad +# A.ancestors.include?(B) +# +# # good +# A <= B +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:19 +class RuboCop::Cop::Performance::AncestorsInclude < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:26 + def ancestors_include_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:30 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:43 + def range(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:23 +RuboCop::Cop::Performance::AncestorsInclude::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/ancestors_include.rb:24 +RuboCop::Cop::Performance::AncestorsInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where slicing arrays with semi-infinite ranges +# can be replaced by `Array#take` and `Array#drop`. +# This cop was created due to a mistake in microbenchmark and hence is disabled by default. +# Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717 +# +# @example +# # bad +# array[..2] +# array[...2] +# array[2..] +# array[2...] +# array.slice(..2) +# +# # good +# array.take(3) +# array.take(2) +# array.drop(2) +# array.drop(2) +# array.take(3) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:29 +class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:45 + def endless_range?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:41 + def endless_range_slice?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:52 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:65 + def correction(receiver, range_node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:36 +RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:39 +RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/array_semi_infinite_range_slice.rb:38 +RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::SLICE_METHODS = T.let(T.unsafe(nil), Set) + +# Identifies places where numeric argument to BigDecimal should be +# converted to string. Initializing from String is faster +# than from Numeric for BigDecimal. +# +# @example +# # bad +# BigDecimal(1, 2) +# 4.to_d(6) +# BigDecimal(1.2, 3, exception: true) +# 4.5.to_d(6, exception: true) +# +# # good +# BigDecimal('1', 2) +# BigDecimal('4', 6) +# BigDecimal('1.2', 3, exception: true) +# BigDecimal('4.5', 6, exception: true) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:23 +class RuboCop::Cop::Performance::BigDecimalWithNumericArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:29 + def big_decimal_with_numeric_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:37 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:33 + def to_d?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:26 +RuboCop::Cop::Performance::BigDecimalWithNumericArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/big_decimal_with_numeric_argument.rb:27 +RuboCop::Cop::Performance::BigDecimalWithNumericArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.7, `UnboundMethod#bind_call` has been added. +# +# This cop identifies places where `bind(obj).call(args, ...)` +# can be replaced by `bind_call(obj, args, ...)`. +# +# The `bind_call(obj, args, ...)` method is faster than +# `bind(obj).call(args, ...)`. +# +# @example +# # bad +# umethod.bind(obj).call(foo, bar) +# umethod.bind(obj).(foo, bar) +# +# # good +# umethod.bind_call(obj, foo, bar) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:22 +class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:33 + def bind_with_call_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:41 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:72 + def build_call_args(call_args_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:65 + def correction_range(receiver, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:59 + def message(bind_arg, call_args); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:29 +RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/bind_call.rb:31 +RuboCop::Cop::Performance::BindCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies unnecessary use of a `block_given?` where explicit check +# of block argument would suffice. +# +# @example +# # bad +# def method(&block) +# do_something if block_given? +# end +# +# # good +# def method(&block) +# do_something if block +# end +# +# # good - block is reassigned +# def method(&block) +# block ||= -> { do_something } +# warn "Using default ..." unless block_given? +# # ... +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb:27 +class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb:35 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb:33 + def reassigns_block_arg?(param0 = T.unsafe(nil), param1); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb:31 +RuboCop::Cop::Performance::BlockGivenWithExplicitBlock::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/block_given_with_explicit_block.rb:30 +RuboCop::Cop::Performance::BlockGivenWithExplicitBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `caller[n]` can be replaced by `caller(n..n).first`. +# +# @example +# # bad +# caller[1] +# caller.first +# caller_locations[1] +# caller_locations.first +# +# # good +# caller(2..2).first +# caller(1..1).first +# caller_locations(2..2).first +# caller_locations(1..1).first +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:20 +class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:33 + def caller_with_scope_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:40 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:26 + def slow_caller?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:61 + def int_value(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:23 +RuboCop::Cop::Performance::Caller::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/caller.rb:24 +RuboCop::Cop::Performance::Caller::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Reordering `when` conditions with a splat to the end +# of the `when` branches can improve performance. +# +# Ruby has to allocate memory for the splat expansion every time +# that the `case` `when` statement is run. Since Ruby does not support +# fall through inside of `case` `when`, like some other languages do, +# the order of the `when` branches should not matter. By placing any +# splat expansions at the end of the list of `when` branches we will +# reduce the number of times that memory has to be allocated for +# the expansion. The exception to this is if multiple of your `when` +# conditions can be true for any given condition. A likely scenario for +# this defining a higher level when condition to override a condition +# that is inside of the splat expansion. +# +# @example +# # bad +# case foo +# when *condition +# bar +# when baz +# foobar +# end +# +# case foo +# when *[1, 2, 3, 4] +# bar +# when 5 +# baz +# end +# +# # good +# case foo +# when baz +# foobar +# when *condition +# bar +# end +# +# case foo +# when 1, 2, 3, 4 +# bar +# when 5 +# baz +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:58 +class RuboCop::Cop::Performance::CaseWhenSplat < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:66 + def on_case(case_node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:83 + def autocorrect(corrector, when_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:144 + def indent_for(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:100 + def inline_fix_branch(corrector, when_node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:169 + def needs_reorder?(when_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:140 + def new_branch_without_then(node, new_condition); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:136 + def new_condition_with_then(node, new_condition); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:162 + def non_splat?(condition); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:91 + def range(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:108 + def reorder_condition(corrector, when_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:118 + def reordering_correction(when_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:95 + def replacement(conditions); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:148 + def splat_offenses(when_conditions); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:128 + def when_branch_range(when_node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:64 +RuboCop::Cop::Performance::CaseWhenSplat::ARRAY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/case_when_splat.rb:63 +RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where a case-insensitive string comparison +# can better be implemented using `casecmp`. +# +# @example +# # bad +# str.downcase == 'abc' +# str.upcase.eql? 'ABC' +# 'abc' == str.downcase +# 'ABC'.eql? str.upcase +# str.downcase == str.downcase +# +# # good +# str.casecmp('ABC').zero? +# 'abc'.casecmp(str).zero? +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:24 +class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:45 + def downcase_downcase(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:31 + def downcase_eq(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:38 + def eq_downcase(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:52 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:84 + def autocorrect(corrector, node, replacement); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:88 + def build_good_method(method, arg, variable); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:67 + def take_method_apart(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:29 +RuboCop::Cop::Performance::Casecmp::CASE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:27 +RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/casecmp.rb:28 +RuboCop::Cop::Performance::Casecmp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies usages of `array.compact.flatten.map { |x| x.downcase }`. +# Each of these methods (`compact`, `flatten`, `map`) will generate a new intermediate array +# that is promptly thrown away. Instead it is faster to mutate when we know it's safe. +# +# @example +# # bad +# array = ["a", "b", "c"] +# array.compact.flatten.map { |x| x.downcase } +# +# # good +# array = ["a", "b", "c"] +# array.compact! +# array.flatten! +# array.map! { |x| x.downcase } +# array +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:21 +class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:54 + def chain_array_allocation?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:62 + def on_send(node); end +end + +# These methods ALWAYS return a new array +# after they're called it's safe to mutate the the resulting array +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:37 +RuboCop::Cop::Performance::ChainArrayAllocation::ALWAYS_RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), Set) + +# These methods have a mutation alternative. For example :collect +# can be called as :collect! +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:45 +RuboCop::Cop::Performance::ChainArrayAllocation::HAS_MUTATION_ALTERNATIVE = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:50 +RuboCop::Cop::Performance::ChainArrayAllocation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:48 +RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), Set) + +# These methods return a new array only when called without a block. +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:33 +RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = T.let(T.unsafe(nil), Set) + +# These methods return a new array but only sometimes. They must be +# called with an argument. For example: +# +# [1,2].first # => 1 +# [1,2].first(1) # => [1] +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/chain_array_allocation.rb:30 +RuboCop::Cop::Performance::ChainArrayAllocation::RETURN_NEW_ARRAY_WHEN_ARGS = T.let(T.unsafe(nil), Set) + +# Identifies places where Array and Hash literals are used within loops. +# It is better to extract them into a local variable or constant +# to avoid unnecessary allocations on each iteration. +# +# You can set the minimum number of elements to consider +# an offense with `MinSize`. +# +# @example +# # bad +# users.select do |user| +# %i[superadmin admin].include?(user.role) +# end +# +# # good +# admin_roles = %i[superadmin admin] +# users.select do |user| +# admin_roles.include?(user.role) +# end +# +# # good +# ADMIN_ROLES = %i[superadmin admin] +# ... +# users.select do |user| +# ADMIN_ROLES.include?(user.role) +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:34 +class RuboCop::Cop::Performance::CollectionLiteralInLoop < ::RuboCop::Cop::Base + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:74 + def enumerable_loop?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:68 + def kernel_loop?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:80 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:90 + def check_literal?(node, method); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:130 + def enumerable_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:112 + def keyword_loop?(type); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:122 + def literal_class(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:106 + def loop?(ancestor, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:134 + def min_size; end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:116 + def node_within_enumerable_loop?(node, ancestor); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:97 + def nonmutable_method_of_array_or_hash?(node, method); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:102 + def parent_is_loop?(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:56 +RuboCop::Cop::Performance::CollectionLiteralInLoop::ARRAY_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:41 +RuboCop::Cop::Performance::CollectionLiteralInLoop::ENUMERABLE_METHOD_NAMES = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:66 +RuboCop::Cop::Performance::CollectionLiteralInLoop::HASH_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:39 +RuboCop::Cop::Performance::CollectionLiteralInLoop::LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:35 +RuboCop::Cop::Performance::CollectionLiteralInLoop::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:42 +RuboCop::Cop::Performance::CollectionLiteralInLoop::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:58 +RuboCop::Cop::Performance::CollectionLiteralInLoop::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/collection_literal_in_loop.rb:38 +RuboCop::Cop::Performance::CollectionLiteralInLoop::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# Identifies places where `sort { |a, b| a.foo <=> b.foo }` +# can be replaced by `sort_by(&:foo)`. +# This cop also checks `max` and `min` methods. +# +# @example +# # bad +# array.sort { |a, b| a.foo <=> b.foo } +# array.max { |a, b| a.foo <=> b.foo } +# array.min { |a, b| a.foo <=> b.foo } +# array.sort { |a, b| a[:foo] <=> b[:foo] } +# +# # good +# array.sort_by(&:foo) +# array.sort_by { |v| v.foo } +# array.sort_by do |var| +# var.foo +# end +# array.max_by(&:foo) +# array.min_by(&:foo) +# array.sort_by { |a| a[:foo] } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:26 +class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:34 + def compare?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:48 + def on_block(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:41 + def replaceable_body?(param0 = T.unsafe(nil), param1, param2); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:105 + def compare_range(send, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:84 + def message(send, method, var_a, var_b, args); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:69 + def slow_compare?(method, args_a, args_b); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/compare_with_block.rb:30 +RuboCop::Cop::Performance::CompareWithBlock::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `Concurrent.monotonic_time` +# can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`. +# +# @example +# +# # bad +# Concurrent.monotonic_time +# +# # good +# Process.clock_gettime(Process::CLOCK_MONOTONIC) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb:17 +class RuboCop::Cop::Performance::ConcurrentMonotonicTime < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb:23 + def concurrent_monotonic_time?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb:28 + def on_send(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb:20 +RuboCop::Cop::Performance::ConcurrentMonotonicTime::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/concurrent_monotonic_time.rb:21 +RuboCop::Cop::Performance::ConcurrentMonotonicTime::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Finds regular expressions with dynamic components that are all constants. +# +# Ruby allocates a new Regexp object every time it executes a code containing such +# a regular expression. It is more efficient to extract it into a constant, +# memoize it, or add an `/o` option to perform `#{}` interpolation only once and +# reuse that Regexp object. +# +# @example +# +# # bad +# def tokens(pattern) +# pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/) } +# end +# +# # good +# ALL_SEPARATORS = /\A#{SEPARATORS}\Z/ +# def tokens(pattern) +# pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) } +# end +# +# # good +# def tokens(pattern) +# pattern.scan(TOKEN).reject { |token| token.match?(/\A#{SEPARATORS}\Z/o) } +# end +# +# # good +# def separators +# @separators ||= /\A#{SEPARATORS}\Z/ +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:36 +class RuboCop::Cop::Performance::ConstantRegexp < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:41 + def on_regexp(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:57 + def regexp_escape?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:62 + def include_interpolated_const?(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:53 + def within_allowed_assignment?(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/constant_regexp.rb:39 +RuboCop::Cop::Performance::ConstantRegexp::MSG = T.let(T.unsafe(nil), String) + +# Identifies usages of `count` on an `Enumerable` that +# follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be +# passed to the `count` call. +# +# @example +# # bad +# [1, 2, 3].select { |e| e > 2 }.size +# [1, 2, 3].reject { |e| e > 2 }.size +# [1, 2, 3].select { |e| e > 2 }.length +# [1, 2, 3].reject { |e| e > 2 }.length +# [1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? } +# [1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? } +# array.select(&:value).count +# +# # good +# [1, 2, 3].count { |e| e > 2 } +# [1, 2, 3].count { |e| e < 2 } +# [1, 2, 3].count { |e| e > 2 && e.odd? } +# [1, 2, 3].count { |e| e < 2 && e.even? } +# Model.select('field AS field_one').count +# Model.select(:value).count +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:49 +class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:56 + def count_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:63 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:79 + def autocorrect(corrector, node, selector_node, selector); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:90 + def eligible_node?(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:94 + def source_starting_at(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:53 +RuboCop::Cop::Performance::Count::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/count.rb:54 +RuboCop::Cop::Performance::Count::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.5, `String#delete_prefix` has been added. +# +# This cop identifies places where `gsub(/\Aprefix/, '')` and `sub(/\Aprefix/, '')` +# can be replaced by `delete_prefix('prefix')`. +# +# This cop has `SafeMultiline` configuration option that `true` by default because +# `^prefix` is unsafe as it will behave incompatible with `delete_prefix` +# for receiver is multiline string. +# +# The `delete_prefix('prefix')` method is faster than `gsub(/\Aprefix/, '')`. +# +# @example +# +# # bad +# str.gsub(/\Aprefix/, '') +# str.gsub!(/\Aprefix/, '') +# +# str.sub(/\Aprefix/, '') +# str.sub!(/\Aprefix/, '') +# +# # good +# str.delete_prefix('prefix') +# str.delete_prefix!('prefix') +# @example SafeMultiline: true (default) +# +# # good +# str.gsub(/^prefix/, '') +# str.gsub!(/^prefix/, '') +# str.sub(/^prefix/, '') +# str.sub!(/^prefix/, '') +# @example SafeMultiline: false +# +# # bad +# str.gsub(/^prefix/, '') +# str.gsub!(/^prefix/, '') +# str.sub(/^prefix/, '') +# str.sub!(/^prefix/, '') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:49 +class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RegexpMetacharacter + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:66 + def delete_prefix_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:70 + def on_send(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:56 +RuboCop::Cop::Performance::DeletePrefix::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:59 +RuboCop::Cop::Performance::DeletePrefix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_prefix.rb:57 +RuboCop::Cop::Performance::DeletePrefix::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.5, `String#delete_suffix` has been added. +# +# This cop identifies places where `gsub(/suffix\z/, '')` and `sub(/suffix\z/, '')` +# can be replaced by `delete_suffix('suffix')`. +# +# This cop has `SafeMultiline` configuration option that `true` by default because +# `suffix$` is unsafe as it will behave incompatible with `delete_suffix?` +# for receiver is multiline string. +# +# The `delete_suffix('suffix')` method is faster than `gsub(/suffix\z/, '')`. +# +# @example +# +# # bad +# str.gsub(/suffix\z/, '') +# str.gsub!(/suffix\z/, '') +# +# str.sub(/suffix\z/, '') +# str.sub!(/suffix\z/, '') +# +# # good +# str.delete_suffix('suffix') +# str.delete_suffix!('suffix') +# @example SafeMultiline: true (default) +# +# # good +# str.gsub(/suffix$/, '') +# str.gsub!(/suffix$/, '') +# str.sub(/suffix$/, '') +# str.sub!(/suffix$/, '') +# @example SafeMultiline: false +# +# # bad +# str.gsub(/suffix$/, '') +# str.gsub!(/suffix$/, '') +# str.sub(/suffix$/, '') +# str.sub!(/suffix$/, '') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:49 +class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RegexpMetacharacter + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:66 + def delete_suffix_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:70 + def on_send(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:56 +RuboCop::Cop::Performance::DeleteSuffix::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:59 +RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/delete_suffix.rb:57 +RuboCop::Cop::Performance::DeleteSuffix::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies usages of `first`, `last`, `[0]` or `[-1]` +# chained to `select`, `find_all` or `filter` and change them to use +# `detect` instead. +# +# @example +# # bad +# [].select { |item| true }.first +# [].select { |item| true }.last +# [].find_all { |item| true }.first +# [].find_all { |item| true }.last +# [].filter { |item| true }.first +# [].filter { |item| true }.last +# [].filter { |item| true }[0] +# [].filter { |item| true }[-1] +# +# # good +# [].detect { |item| true } +# [].reverse.detect { |item| true } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:30 +class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:41 + def detect_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:50 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:69 + def accept_first_call?(receiver, body); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:101 + def autocorrect(corrector, node, replacement); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:127 + def lazy?(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:112 + def message_for_method(method, index); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:123 + def preferred_method; end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:78 + def register_offense(node, receiver, second_method, index); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:93 + def replacement(method, index); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:33 +RuboCop::Cop::Performance::Detect::CANDIDATE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:37 +RuboCop::Cop::Performance::Detect::INDEX_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:38 +RuboCop::Cop::Performance::Detect::INDEX_REVERSE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:35 +RuboCop::Cop::Performance::Detect::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:39 +RuboCop::Cop::Performance::Detect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/detect.rb:36 +RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String) + +# Checks for double `#start_with?` or `#end_with?` calls +# separated by `||`. In some cases such calls can be replaced +# with an single `#start_with?`/`#end_with?` call. +# +# `IncludeActiveSupportAliases` configuration option is used to check for +# `starts_with?` and `ends_with?`. These methods are defined by Active Support. +# +# @example +# # bad +# str.start_with?("a") || str.start_with?(Some::CONST) +# str.start_with?("a", "b") || str.start_with?("c") +# str.end_with?(var1) || str.end_with?(var2) +# +# # good +# str.start_with?("a", Some::CONST) +# str.start_with?("a", "b", "c") +# str.end_with?(var1, var2) +# @example IncludeActiveSupportAliases: false (default) +# # good +# str.starts_with?("a", "b") || str.starts_with?("c") +# str.ends_with?(var1) || str.ends_with?(var2) +# +# str.starts_with?("a", "b", "c") +# str.ends_with?(var1, var2) +# @example IncludeActiveSupportAliases: true +# # bad +# str.starts_with?("a", "b") || str.starts_with?("c") +# str.ends_with?(var1) || str.ends_with?(var2) +# +# # good +# str.starts_with?("a", "b", "c") +# str.ends_with?(var1, var2) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:41 +class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:97 + def check_with_active_support_aliases(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:47 + def on_or(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:91 + def two_start_end_with_calls(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:61 + def autocorrect(corrector, first_call_args, second_call_args, combined_args); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:87 + def check_for_active_support_aliases?; end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:83 + def combine_args(first_call_args, second_call_args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:77 + def message(node, receiver, method, combined_args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:69 + def process_source(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/double_start_end_with.rb:44 +RuboCop::Cop::Performance::DoubleStartEndWith::MSG = T.let(T.unsafe(nil), String) + +# Identifies unnecessary use of a regex where `String#end_with?` would suffice. +# +# This cop has `SafeMultiline` configuration option that `true` by default because +# `end$` is unsafe as it will behave incompatible with `end_with?` +# for receiver is multiline string. +# +# @example +# # bad +# 'abc'.match?(/bc\Z/) +# /bc\Z/.match?('abc') +# 'abc' =~ /bc\Z/ +# /bc\Z/ =~ 'abc' +# 'abc'.match(/bc\Z/) +# /bc\Z/.match('abc') +# +# # good +# 'abc'.end_with?('bc') +# @example SafeMultiline: true (default) +# +# # good +# 'abc'.match?(/bc$/) +# /bc$/.match?('abc') +# 'abc' =~ /bc$/ +# /bc$/ =~ 'abc' +# 'abc'.match(/bc$/) +# /bc$/.match('abc') +# @example SafeMultiline: false +# +# # bad +# 'abc'.match?(/bc$/) +# /bc$/.match?('abc') +# 'abc' =~ /bc$/ +# /bc$/ =~ 'abc' +# 'abc'.match(/bc$/) +# /bc$/.match('abc') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:49 +class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RegexpMetacharacter + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:63 + def on_match_with_lvasgn(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:63 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:57 + def redundant_regex?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:53 +RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/end_with.rb:55 +RuboCop::Cop::Performance::EndWith::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Do not compute the size of statically sized objects. +# +# @example +# # String methods +# # bad +# 'foo'.size +# %q[bar].count +# %(qux).length +# +# # Symbol methods +# # bad +# :fred.size +# :'baz'.length +# +# # Array methods +# # bad +# [1, 2, thud].count +# %W(1, 2, bar).size +# +# # Hash methods +# # bad +# { a: corge, b: grault }.length +# +# # good +# foo.size +# bar.count +# qux.length +# +# # good +# :"#{fred}".size +# CONST = :baz.length +# +# # good +# [1, 2, *thud].count +# garply = [1, 2, 3] +# garply.size +# +# # good +# { a: corge, **grault }.length +# waldo = { a: corge, b: grault } +# waldo.size +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:48 +class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Base + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:52 + def counter(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:56 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:72 + def allowed_argument?(arg); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:76 + def allowed_parent?(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:68 + def allowed_variable?(var); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:86 + def contains_double_splat?(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:80 + def contains_splat?(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:92 + def non_string_argument?(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:49 +RuboCop::Cop::Performance::FixedSize::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/fixed_size.rb:50 +RuboCop::Cop::Performance::FixedSize::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies usages of `map { ... }.flatten` and +# change them to use `flat_map { ... }` instead. +# +# @example +# # bad +# [1, 2, 3, 4].map { |e| [e, e] }.flatten(1) +# [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1) +# +# # good +# [1, 2, 3, 4].flat_map { |e| [e, e] } +# [1, 2, 3, 4].map { |e| [e, e] }.flatten +# [1, 2, 3, 4].collect { |e| [e, e] }.flatten +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:18 +class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:28 + def flat_map_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:39 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:71 + def autocorrect(corrector, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:52 + def offense_for_levels(node, map_node, first_method, flatten); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:58 + def offense_for_method(node, map_node, first_method, flatten); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:62 + def register_offense(node, map_node, first_method, flatten, message); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:24 +RuboCop::Cop::Performance::FlatMap::FLATTEN_MULTIPLE_LEVELS = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:22 +RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/flat_map.rb:23 +RuboCop::Cop::Performance::FlatMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for inefficient searching of keys and values within +# hashes. +# +# `Hash#keys.include?` is less efficient than `Hash#key?` because +# the former allocates a new array and then performs an O(n) search +# through that array, while `Hash#key?` does not allocate any array and +# performs a faster O(1) search for the key. +# +# `Hash#values.include?` is less efficient than `Hash#value?`. While they +# both perform an O(n) search through all of the values, calling `values` +# allocates a new array while using `value?` does not. +# +# @example +# # bad +# { a: 1, b: 2 }.keys.include?(:a) +# { a: 1, b: 2 }.keys.include?(:z) +# h = { a: 1, b: 2 }; h.keys.include?(100) +# +# # good +# { a: 1, b: 2 }.key?(:a) +# { a: 1, b: 2 }.has_key?(:z) +# h = { a: 1, b: 2 }; h.key?(100) +# +# # bad +# { a: 1, b: 2 }.values.include?(2) +# { a: 1, b: 2 }.values.include?('garbage') +# h = { a: 1, b: 2 }; h.values.include?(nil) +# +# # good +# { a: 1, b: 2 }.value?(2) +# { a: 1, b: 2 }.has_value?('garbage') +# h = { a: 1, b: 2 }; h.value?(nil) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:42 +class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:47 + def inefficient_include?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:51 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:91 + def autocorrect_argument(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:95 + def autocorrect_hash_expression(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:73 + def autocorrect_method(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:80 + def current_method(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:69 + def message(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:84 + def use_long_method; end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/inefficient_hash_search.rb:45 +RuboCop::Cop::Performance::InefficientHashSearch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where inefficient `readlines` method +# can be replaced by `each_line` to avoid fully loading file content into memory. +# +# @example +# +# # bad +# File.readlines('testfile').each { |l| puts l } +# IO.readlines('testfile', chomp: true).each { |l| puts l } +# +# conn.readlines(10).map { |l| l.size } +# file.readlines.find { |l| l.start_with?('#') } +# file.readlines.each { |l| puts l } +# +# # good +# File.open('testfile', 'r').each_line { |l| puts l } +# IO.open('testfile').each_line(chomp: true) { |l| puts l } +# +# conn.each_line(10).map { |l| l.size } +# file.each_line.find { |l| l.start_with?('#') } +# file.each_line { |l| puts l } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:27 +class RuboCop::Cop::Performance::IoReadlines < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:42 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:34 + def readlines_on_class?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:38 + def readlines_on_instance?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:58 + def autocorrect(corrector, enumerable_call, readlines_call, receiver); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:90 + def build_bad_method(enumerable_call); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:106 + def build_call_args(call_args_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:82 + def build_good_method(enumerable_call); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:94 + def correction_range(enumerable_call, readlines_call); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:76 + def offense_range(enumerable_call, readlines_call); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:31 +RuboCop::Cop::Performance::IoReadlines::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/io_readlines.rb:32 +RuboCop::Cop::Performance::IoReadlines::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.7, `Enumerable#filter_map` has been added. +# +# This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`. +# +# [source,ruby] +# ---- +# [true, false, nil].compact #=> [true, false] +# [true, false, nil].filter_map(&:itself) #=> [true] +# ---- +# +# @example +# # bad +# ary.map(&:foo).compact +# ary.collect(&:foo).compact +# +# # good +# ary.filter_map(&:foo) +# ary.map(&:foo).compact! +# ary.compact.map(&:foo) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:30 +class RuboCop::Cop::Performance::MapCompact < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:40 + def map_compact(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:53 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:89 + def compact_method_with_final_newline_range(compact_method_range); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:85 + def invoke_method_after_map_compact_on_same_line?(compact_node, chained_method); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:81 + def map_method_and_compact_method_on_same_line?(map_node, compact_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:67 + def remove_compact_method(corrector, map_node, compact_node, chained_method); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:35 +RuboCop::Cop::Performance::MapCompact::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/map_compact.rb:36 +RuboCop::Cop::Performance::MapCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where methods are converted to blocks, with the +# use of `&method`, and passed as arguments to method calls. +# It is faster to replace those with explicit blocks, calling those methods inside. +# +# @example +# # bad +# array.map(&method(:do_something)) +# [1, 2, 3].each(&out.method(:puts)) +# +# # good +# array.map { |x| do_something(x) } +# [1, 2, 3].each { |x| out.puts(x) } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb:19 +class RuboCop::Cop::Performance::MethodObjectAsBlock < ::RuboCop::Cop::Base + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb:22 + def method_object_as_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb:26 + def on_block_pass(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/method_object_as_block.rb:20 +RuboCop::Cop::Performance::MethodObjectAsBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for `OpenStruct.new` calls. +# Instantiation of an `OpenStruct` invalidates +# Ruby global method cache as it causes dynamic method +# definition during program runtime. +# This could have an effect on performance, +# especially in case of single-threaded +# applications with multiple `OpenStruct` instantiations. +# +# @example +# # bad +# class MyClass +# def my_method +# OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2') +# end +# end +# +# # good +# class MyClass +# MyStruct = Struct.new(:my_key1, :my_key2) +# def my_method +# MyStruct.new('my_value1', 'my_value2') +# end +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb:34 +class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Base + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb:43 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb:39 + def open_struct(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb:35 +RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/open_struct.rb:37 +RuboCop::Cop::Performance::OpenStruct::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies uses of `Range#include?` and `Range#member?`, which iterates over each +# item in a `Range` to see if a specified item is there. In contrast, +# `Range#cover?` simply compares the target item with the beginning and +# end points of the `Range`. In a great majority of cases, this is what +# is wanted. +# +# @example +# # bad +# ('a'..'z').include?('b') # => true +# ('a'..'z').member?('b') # => true +# +# # good +# ('a'..'z').cover?('b') # => true +# +# # Example of a case where `Range#cover?` may not provide +# # the desired result: +# +# ('a'..'z').cover?('yellow') # => true +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb:28 +class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb:43 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb:39 + def range_include(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb:31 +RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/range_include.rb:32 +RuboCop::Cop::Performance::RangeInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies the use of a `&block` parameter and `block.call` +# where `yield` would do just as well. +# +# @example +# # bad +# def method(&block) +# block.call +# end +# def another(&func) +# func.call 1, 2, 3 +# end +# +# # good +# def method +# yield +# end +# def another +# yield 1, 2, 3 +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:25 +class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:43 + def blockarg_assigned?(param0, param1); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:39 + def blockarg_calls(param0, param1); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:34 + def blockarg_def(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:47 + def on_def(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:47 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:97 + def args_include_block_pass?(blockcall); end + + # offenses are registered on the `block.call` nodes + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:63 + def autocorrect(corrector, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:81 + def calls_to_report(argname, body); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:91 + def shadowed_block_argument?(body, block_argument_of_method_signature); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:31 +RuboCop::Cop::Performance::RedundantBlockCall::CLOSE_PAREN = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:28 +RuboCop::Cop::Performance::RedundantBlockCall::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:30 +RuboCop::Cop::Performance::RedundantBlockCall::OPEN_PAREN = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:32 +RuboCop::Cop::Performance::RedundantBlockCall::SPACE = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_block_call.rb:29 +RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), String) + +# Checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`, +# and `Enumerable#none?` are compared with `===` or similar methods in block. +# +# By default, `Object#===` behaves the same as `Object#==`, but this +# behavior is appropriately overridden in subclass. For example, +# `Range#===` returns `true` when argument is within the range. +# +# @example +# # bad +# items.all? { |item| pattern === item } +# items.all? { |item| item == other } +# items.all? { |item| item.is_a?(Klass) } +# items.all? { |item| item.kind_of?(Klass) } +# +# # good +# items.all?(pattern) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:26 +class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:38 + def on_block(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:76 + def new_argument(block_argument, block_body); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:99 + def offense_range(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:58 + def one_block_argument?(block_arguments); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:66 + def same_block_argument_and_is_a_argument?(block_body, block_argument); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:90 + def use_block_argument_in_method_argument_of_operand?(block_argument, operand); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:62 + def use_equality_comparison_block?(block_body); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:35 +RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:36 +RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::IS_A_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:32 +RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_equality_comparison_block.rb:34 +RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::TARGET_METHODS = T.let(T.unsafe(nil), Array) + +# Identifies the use of `Regexp#match` or `String#match`, which +# returns `#<MatchData>`/`nil`. The return value of `=~` is an integral +# index/`nil` and is more performant. +# +# @example +# # bad +# do_something if str.match(/regex/) +# while regex.match('str') +# do_something +# end +# +# # good +# method(str =~ /regex/) +# return value unless regex =~ 'str' +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:20 +class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:29 + def match_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:38 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:34 + def only_truthiness_matters?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:50 + def autocorrect(corrector, node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:23 +RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_match.rb:25 +RuboCop::Cop::Performance::RedundantMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `Hash#merge!` can be replaced by `Hash#[]=`. +# You can set the maximum number of key-value pairs to consider +# an offense with `MaxKeyValuePairs`. +# +# @example +# # bad +# hash.merge!(a: 1) +# hash.merge!({'key' => 'value'}) +# +# # good +# hash[:a] = 1 +# hash['key'] = 'value' +# @example MaxKeyValuePairs: 2 (default) +# # bad +# hash.merge!(a: 1, b: 2) +# +# # good +# hash[:a] = 1 +# hash[:b] = 2 +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:30 +class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:47 + def modifier_flow_control?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:51 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:43 + def redundant_merge_candidate(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:106 + def correct_multiple_elements(corrector, node, parent, new_source); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:118 + def correct_single_element(corrector, node, new_source); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:78 + def each_redundant_merge(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:150 + def indent_width; end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:97 + def kwsplat_used?(pairs); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:146 + def leading_spaces(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:154 + def max_key_value_pairs; end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:70 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:86 + def non_redundant_merge?(node, receiver, pairs); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:93 + def non_redundant_pairs?(receiver, pairs); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:101 + def non_redundant_value_used?(receiver, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:134 + def rewrite_with_modifier(node, parent, new_source); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:122 + def to_assignments(receiver, pairs); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:33 +RuboCop::Cop::Performance::RedundantMerge::AREF_ASGN = T.let(T.unsafe(nil), String) + +# A utility class for checking the use of values within an +# `each_with_object` call. +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:160 +class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector + extend ::RuboCop::AST::NodePattern::Macros + + # @return [EachWithObjectInspector] a new instance of EachWithObjectInspector + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:163 + def initialize(node, receiver); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:194 + def each_with_object_node(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:168 + def value_used?; end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:178 + def eligible_receiver?; end + + # Returns the value of attribute node. + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:176 + def node; end + + # Returns the value of attribute receiver. + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:176 + def receiver; end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:182 + def second_argument; end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:189 + def unwind(receiver); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:34 +RuboCop::Cop::Performance::RedundantMerge::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:35 +RuboCop::Cop::Performance::RedundantMerge::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_merge.rb:37 +RuboCop::Cop::Performance::RedundantMerge::WITH_MODIFIER_CORRECTION = T.let(T.unsafe(nil), String) + +# Identifies places where `sort { |a, b| a <=> b }` can be replaced with `sort`. +# +# @example +# # bad +# array.sort { |a, b| a <=> b } +# +# # good +# array.sort +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb:15 +class RuboCop::Cop::Performance::RedundantSortBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SortBlock + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb:21 + def on_block(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb:35 + def message(var_a, var_b); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_sort_block.rb:19 +RuboCop::Cop::Performance::RedundantSortBlock::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `split` argument can be replaced from +# a deterministic regexp to a string. +# +# @example +# # bad +# 'a,b,c'.split(/,/) +# +# # good +# 'a,b,c'.split(',') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:15 +class RuboCop::Cop::Performance::RedundantSplitRegexpArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:27 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:23 + def split_call_with_regexp?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:41 + def determinist_regexp?(regexp_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:45 + def replacement(regexp_node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:20 +RuboCop::Cop::Performance::RedundantSplitRegexpArgument::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:18 +RuboCop::Cop::Performance::RedundantSplitRegexpArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:19 +RuboCop::Cop::Performance::RedundantSplitRegexpArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_split_regexp_argument.rb:21 +RuboCop::Cop::Performance::RedundantSplitRegexpArgument::STR_SPECIAL_CHARS = T.let(T.unsafe(nil), Array) + +# Checks for redundant `String#chars`. +# +# @example +# # bad +# str.chars[0..2] +# str.chars.slice(0..2) +# +# # good +# str[0..2].chars +# +# # bad +# str.chars.first +# str.chars.first(2) +# +# # good +# str[0] +# str[0...2].chars +# +# # bad +# str.chars.take(2) +# str.chars.length +# str.chars.size +# str.chars.empty? +# +# # good +# str[0...2].chars +# str.length +# str.size +# str.empty? +# +# # For example, if the receiver is a blank string, it will be incompatible. +# # If a negative value is specified for the receiver, `nil` is returned. +# str.chars.last # Incompatible with `str[-1]`. +# str.chars.last(2) # Incompatible with `str[-2..-1].chars`. +# str.chars.drop(2) # Incompatible with `str[2..-1].chars`. +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:42 +class RuboCop::Cop::Performance::RedundantStringChars < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:53 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:49 + def redundant_chars_call?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:108 + def build_bad_method(method, args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:121 + def build_call_args(call_args_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:83 + def build_good_method(method, args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:96 + def build_good_method_for_brackets_or_first_method(method, args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:77 + def build_message(method, args); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:73 + def correction_range(receiver, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:69 + def offense_range(receiver, node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:46 +RuboCop::Cop::Performance::RedundantStringChars::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/redundant_string_chars.rb:47 +RuboCop::Cop::Performance::RedundantStringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.4, `String#match?`, `Regexp#match?`, and `Symbol#match?` +# have been added. The methods are faster than `match`. +# Because the methods avoid creating a `MatchData` object or saving +# backref. +# So, when `MatchData` is not used, use `match?` instead of `match`. +# +# @example +# # bad +# def foo +# if x =~ /re/ +# do_something +# end +# end +# +# # bad +# def foo +# if x !~ /re/ +# do_something +# end +# end +# +# # bad +# def foo +# if x.match(/re/) +# do_something +# end +# end +# +# # bad +# def foo +# if /re/ === x +# do_something +# end +# end +# +# # good +# def foo +# if x.match?(/re/) +# do_something +# end +# end +# +# # good +# def foo +# if !x.match?(/re/) +# do_something +# end +# end +# +# # good +# def foo +# if x =~ /re/ +# do_something(Regexp.last_match) +# end +# end +# +# # good +# def foo +# if x.match(/re/) +# do_something($~) +# end +# end +# +# # good +# def foo +# if /re/ === x +# do_something($~) +# end +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:75 +class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:125 + def last_matches(param0); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:86 + def match_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:122 + def match_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:97 + def match_operator?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:101 + def match_threequals?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:93 + def match_with_int_arg_method?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:105 + def match_with_lvasgn?(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:138 + def on_case(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:134 + def on_if(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:123 + def search_match_nodes(param0); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:161 + def autocorrect(corrector, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:150 + def check_condition(cond); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:254 + def correct_operator(corrector, recv, arg, oper = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:279 + def correction_range(recv, arg); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:217 + def find_last_match(body, range, scope_root); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:177 + def last_match_used?(match_node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:243 + def match_gvar?(sym); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:173 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:213 + def modifier_form?(match_node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:199 + def next_match_pos(body, match_node_pos, scope_root); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:186 + def range_to_search_for_last_matches(match_node, body, scope_root); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:263 + def replace_with_match_predicate_method(corrector, recv, arg, op_range); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:225 + def scope_body(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:237 + def scope_root(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:274 + def swap_receiver_and_arg(corrector, recv, arg); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:112 +RuboCop::Cop::Performance::RegexpMatch::MATCH_NODE_PATTERN = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:84 +RuboCop::Cop::Performance::RegexpMatch::MSG = T.let(T.unsafe(nil), String) + +# Constants are included in this list because it is unlikely that +# someone will store `nil` as a constant and then use it for comparison +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/regexp_match.rb:83 +RuboCop::Cop::Performance::RegexpMatch::TYPES_IMPLEMENTING_MATCH = T.let(T.unsafe(nil), Array) + +# Identifies usages of `reverse.each` and change them to use `reverse_each` instead. +# +# If the return value is used, it will not be detected because the result will be different. +# +# [source,ruby] +# ---- +# [1, 2, 3].reverse.each {} #=> [3, 2, 1] +# [1, 2, 3].reverse_each {} #=> [1, 2, 3] +# ---- +# +# @example +# # bad +# items.reverse.each +# +# # good +# items.reverse_each +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:22 +class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:33 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:29 + def reverse_each?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:53 + def offense_range(node); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:47 + def use_return_value?(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:26 +RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_each.rb:27 +RuboCop::Cop::Performance::ReverseEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `reverse.first(n)` and `reverse.first` +# can be replaced by `last(n).reverse` and `last`. +# +# @example +# +# # bad +# array.reverse.first(5) +# array.reverse.first +# +# # good +# array.last(5).reverse +# array.last +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:19 +class RuboCop::Cop::Performance::ReverseFirst < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:30 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:26 + def reverse_first_candidate?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:63 + def build_bad_method(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:55 + def build_good_method(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:49 + def build_message(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:45 + def correction_range(receiver, node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:23 +RuboCop::Cop::Performance::ReverseFirst::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/reverse_first.rb:24 +RuboCop::Cop::Performance::ReverseFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.7, `Enumerable#filter_map` has been added. +# +# This cop identifies places where `select.map` can be replaced by `filter_map`. +# +# @example +# # bad +# ary.select(&:foo).map(&:bar) +# ary.filter(&:foo).map(&:bar) +# +# # good +# ary.filter_map { |o| o.bar if o.foo } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:18 +class RuboCop::Cop::Performance::SelectMap < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:27 + def bad_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:31 + def on_send(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:44 + def map_method_candidate(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:54 + def offense_range(node, map_method); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:24 +RuboCop::Cop::Performance::SelectMap::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/select_map.rb:25 +RuboCop::Cop::Performance::SelectMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies usages of `count` on an `Array` and `Hash` and change them to `size`. +# +# TODO: Add advanced detection of variables that could +# have been assigned to an array or a hash. +# +# @example +# # bad +# [1, 2, 3].count +# (1..3).to_a.count +# Array[*1..3].count +# Array(1..3).count +# +# # bad +# {a: 1, b: 2, c: 3}.count +# [[:foo, :bar], [1, 2]].to_h.count +# Hash[*('a'..'z')].count +# Hash(key: :value).count +# +# # good +# [1, 2, 3].size +# (1..3).to_a.size +# Array[*1..3].size +# Array(1..3).size +# +# # good +# {a: 1, b: 2, c: 3}.size +# [[:foo, :bar], [1, 2]].to_h.size +# Hash[*('a'..'z')].size +# Hash(key: :value).size +# +# # good +# [1, 2, 3].count { |e| e > 2 } +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:37 +class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:43 + def array?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:61 + def count?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:52 + def hash?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:65 + def on_send(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:40 +RuboCop::Cop::Performance::Size::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/size.rb:41 +RuboCop::Cop::Performance::Size::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `sort { |a, b| b <=> a }` +# can be replaced by a faster `sort.reverse`. +# +# @example +# # bad +# array.sort { |a, b| b <=> a } +# +# # good +# array.sort.reverse +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb:16 +class RuboCop::Cop::Performance::SortReverse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SortBlock + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb:22 + def on_block(node); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb:38 + def message(var_a, var_b); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sort_reverse.rb:20 +RuboCop::Cop::Performance::SortReverse::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')` +# can be replaced by `squeeze('a')` and `squeeze!('a')`. +# +# The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`. +# +# @example +# +# # bad +# str.gsub(/a+/, 'a') +# str.gsub!(/a+/, 'a') +# +# # good +# str.squeeze('a') +# str.squeeze!('a') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:21 +class RuboCop::Cop::Performance::Squeeze < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:41 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:32 + def squeeze_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:61 + def repeating_literal?(regex_str); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:24 +RuboCop::Cop::Performance::Squeeze::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:27 +RuboCop::Cop::Performance::Squeeze::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/squeeze.rb:25 +RuboCop::Cop::Performance::Squeeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies unnecessary use of a regex where `String#start_with?` would suffice. +# +# This cop has `SafeMultiline` configuration option that `true` by default because +# `^start` is unsafe as it will behave incompatible with `start_with?` +# for receiver is multiline string. +# +# @example +# # bad +# 'abc'.match?(/\Aab/) +# /\Aab/.match?('abc') +# 'abc' =~ /\Aab/ +# /\Aab/ =~ 'abc' +# 'abc'.match(/\Aab/) +# /\Aab/.match('abc') +# +# # good +# 'abc'.start_with?('ab') +# @example SafeMultiline: true (default) +# +# # good +# 'abc'.match?(/^ab/) +# /^ab/.match?('abc') +# 'abc' =~ /^ab/ +# /^ab/ =~ 'abc' +# 'abc'.match(/^ab/) +# /^ab/.match('abc') +# @example SafeMultiline: false +# +# # bad +# 'abc'.match?(/^ab/) +# /^ab/.match?('abc') +# 'abc' =~ /^ab/ +# /^ab/ =~ 'abc' +# 'abc'.match(/^ab/) +# /^ab/.match('abc') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:49 +class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RegexpMetacharacter + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:63 + def on_match_with_lvasgn(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:63 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:57 + def redundant_regex?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:53 +RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/start_with.rb:55 +RuboCop::Cop::Performance::StartWith::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where string identifier argument can be replaced +# by symbol identifier argument. +# It prevents the redundancy of the internal string-to-symbol conversion. +# +# This cop targets methods that take identifier (e.g. method name) argument +# and the following examples are parts of it. +# +# @example +# +# # bad +# send('do_something') +# attr_accessor 'do_something' +# instance_variable_get('@ivar') +# +# # good +# send(:do_something) +# attr_accessor :do_something +# instance_variable_get(:@ivar) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb:25 +class RuboCop::Cop::Performance::StringIdentifierArgument < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb:46 + def on_send(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb:28 +RuboCop::Cop::Performance::StringIdentifierArgument::MSG = T.let(T.unsafe(nil), String) + +# NOTE: `attr` method is not included in this list as it can cause false positives in Nokogiri API. +# And `attr` may not be used because `Style/Attr` registers an offense. +# https://github.com/rubocop/rubocop-performance/issues/278 +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_identifier_argument.rb:33 +RuboCop::Cop::Performance::StringIdentifierArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies unnecessary use of a regex where `String#include?` would suffice. +# +# @example +# # bad +# 'abc'.match?(/ab/) +# /ab/.match?('abc') +# 'abc' =~ /ab/ +# /ab/ =~ 'abc' +# 'abc'.match(/ab/) +# /ab/.match('abc') +# +# # good +# 'abc'.include?('ab') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:22 +class RuboCop::Cop::Performance::StringInclude < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:34 + def on_match_with_lvasgn(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:34 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:28 + def redundant_regex?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:50 + def literal?(regex_str); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:25 +RuboCop::Cop::Performance::StringInclude::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_include.rb:26 +RuboCop::Cop::Performance::StringInclude::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `gsub` can be replaced by `tr` or `delete`. +# +# @example +# # bad +# 'abc'.gsub('b', 'd') +# 'abc'.gsub('a', '') +# 'abc'.gsub(/a/, 'd') +# 'abc'.gsub!('a', 'd') +# +# # good +# 'abc'.gsub(/.*/, 'a') +# 'abc'.gsub(/a+/, 'd') +# 'abc'.tr('b', 'd') +# 'a b c'.delete(' ') +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:20 +class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:37 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:31 + def string_replacement?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:83 + def accept_first_param?(first_param); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:78 + def accept_second_param?(second_param); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:59 + def autocorrect(corrector, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:100 + def first_source(first_param); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:143 + def message(node, first_source, second_source); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:150 + def method_suffix(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:48 + def offense(node, first_param, second_param); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:129 + def range(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:154 + def remove_second_param(corrector, node, first_param); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:69 + def replace_method(corrector, node, first_source, second_source, first_param); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:133 + def replacement_method(node, first_source, second_source); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:118 + def source_from_regex_constructor(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:111 + def source_from_regex_literal(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:29 +RuboCop::Cop::Performance::StringReplacement::BANG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:27 +RuboCop::Cop::Performance::StringReplacement::DELETE = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:26 +RuboCop::Cop::Performance::StringReplacement::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:24 +RuboCop::Cop::Performance::StringReplacement::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:25 +RuboCop::Cop::Performance::StringReplacement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/string_replacement.rb:28 +RuboCop::Cop::Performance::StringReplacement::TR = T.let(T.unsafe(nil), String) + +# Identifies places where custom code finding the sum of elements +# in some Enumerable object can be replaced by `Enumerable#sum` method. +# +# @example OnlySumOrWithInitialValue: false (default) +# # bad +# [1, 2, 3].inject(:+) # Autocorrections for cases without initial value are unsafe +# [1, 2, 3].inject(&:+) # and will only be performed when using the `-A` option. +# [1, 2, 3].reduce { |acc, elem| acc + elem } # They can be prohibited completely using `SafeAutoCorrect: true`. +# [1, 2, 3].reduce(10, :+) +# [1, 2, 3].map { |elem| elem ** 2 }.sum +# [1, 2, 3].collect(&:count).sum(10) +# +# # good +# [1, 2, 3].sum +# [1, 2, 3].sum(10) +# [1, 2, 3].sum { |elem| elem ** 2 } +# [1, 2, 3].sum(10, &:count) +# @example OnlySumOrWithInitialValue: true +# # bad +# [1, 2, 3].reduce(10, :+) +# [1, 2, 3].map { |elem| elem ** 2 }.sum +# [1, 2, 3].collect(&:count).sum(10) +# +# # good +# [1, 2, 3].sum(10) +# [1, 2, 3].sum { |elem| elem ** 2 } +# [1, 2, 3].sum(10, &:count) +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:70 +class RuboCop::Cop::Performance::Sum < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:99 + def acc_plus_elem?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:99 + def elem_plus_acc?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:111 + def on_block(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:104 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:79 + def sum_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:83 + def sum_map_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:92 + def sum_with_block_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:156 + def array_literal?(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:161 + def autocorrect(corrector, init, range); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:169 + def autocorrect_sum_map(corrector, sum, map, init); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:245 + def build_block_bad_method(method, init, var_acc, var_elem, body); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:212 + def build_block_message(send, init, var_acc, var_elem, body); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:218 + def build_good_method(init, block_pass = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:231 + def build_method_bad_method(init, method, operation); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:194 + def build_method_message(node, method, init, operation); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:205 + def build_sum_map_message(method, init); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:151 + def empty_array_literal?(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:126 + def handle_sum_candidate(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:139 + def handle_sum_map_candidate(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:256 + def method_call_with_args_range(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:190 + def sum_block_range(send, node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:186 + def sum_map_range(map, sum); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:182 + def sum_method_range(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:74 +RuboCop::Cop::Performance::Sum::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:75 +RuboCop::Cop::Performance::Sum::MSG_IF_NO_INIT_VALUE = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/sum.rb:77 +RuboCop::Cop::Performance::Sum::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for .times.map calls. +# In most cases such calls can be replaced +# with an explicit array creation. +# +# @example +# # bad +# 9.times.map do |i| +# i.to_s +# end +# +# # good +# Array.new(9) do |i| +# i.to_s +# end +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:32 +class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:44 + def on_block(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:40 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:70 + def times_map_call(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:50 + def check(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:61 + def message(map_or_collect, count); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:35 +RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:37 +RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/times_map.rb:38 +RuboCop::Cop::Performance::TimesMap::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# In Ruby 2.3 or later, use unary plus operator to unfreeze a string +# literal instead of `String#dup` and `String.new`. +# Unary plus operator is faster than `String#dup`. +# +# @example +# # bad +# ''.dup +# "something".dup +# String.new +# String.new('') +# String.new('something') +# +# # good +# +'something' +# +'' +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:27 +class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:33 + def dup_string?(param0 = T.unsafe(nil)); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:44 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:37 + def string_new?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:57 + def string_value(node); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:30 +RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/unfreeze_string.rb:31 +RuboCop::Cop::Performance::UnfreezeString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `URI::Parser.new` can be replaced by `URI::DEFAULT_PARSER`. +# +# @example +# # bad +# URI::Parser.new +# +# # good +# URI::DEFAULT_PARSER +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb:15 +class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb:28 + def on_send(node); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb:22 + def uri_parser_new?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb:18 +RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-performance-1.14.3/lib/rubocop/cop/performance/uri_default_parser.rb:20 +RuboCop::Cop::Performance::UriDefaultParser::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Common functionality for handling regexp metacharacters. +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:6 +module RuboCop::Cop::RegexpMetacharacter + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:63 + def drop_end_metacharacter(regexp_string); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:55 + def drop_start_metacharacter(regexp_string); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:15 + def literal_at_end?(regexp); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:41 + def literal_at_end_with_backslash_z?(regex_str); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:48 + def literal_at_end_with_dollar?(regex_str); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:9 + def literal_at_start?(regexp); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:21 + def literal_at_start_with_backslash_a?(regex_str); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:31 + def literal_at_start_with_caret?(regex_str); end + + # @return [Boolean] + # + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/regexp_metacharacter.rb:71 + def safe_multiline?; end +end + +# Common functionality for cops checking `Enumerable#sort` blocks. +# +# source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb:6 +module RuboCop::Cop::SortBlock + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb:17 + def replaceable_body?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb:10 + def sort_with_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-performance-1.14.3/lib/rubocop/cop/mixin/sort_block.rb:23 + def sort_range(send, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# RuboCop Performance project namespace +# +# source://rubocop-performance-1.14.3/lib/rubocop/performance.rb:5 +module RuboCop::Performance; end + +# source://rubocop-performance-1.14.3/lib/rubocop/performance.rb:8 +RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash) + +# source://rubocop-performance-1.14.3/lib/rubocop/performance.rb:7 +RuboCop::Performance::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname) + +# Because RuboCop doesn't yet support plugins, we have to monkey patch in a +# bit of our configuration. +# +# source://rubocop-performance-1.14.3/lib/rubocop/performance/inject.rb:7 +module RuboCop::Performance::Inject + class << self + # source://rubocop-performance-1.14.3/lib/rubocop/performance/inject.rb:8 + def defaults!; end + end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/performance.rb:6 +RuboCop::Performance::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname) + +# This module holds the RuboCop Performance version information. +# +# source://rubocop-performance-1.14.3/lib/rubocop/performance/version.rb:6 +module RuboCop::Performance::Version + class << self + # source://rubocop-performance-1.14.3/lib/rubocop/performance/version.rb:9 + def document_version; end + end +end + +# source://rubocop-performance-1.14.3/lib/rubocop/performance/version.rb:7 +RuboCop::Performance::Version::STRING = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token diff --git a/sorbet/rbi/gems/rubocop-rake.rbi b/sorbet/rbi/gems/rubocop-rake.rbi deleted file mode 100644 index 687a9a18..00000000 --- a/sorbet/rbi/gems/rubocop-rake.rbi +++ /dev/null @@ -1,85 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-rake/all/rubocop-rake.rbi -# -# rubocop-rake-0.6.0 - -module RuboCop -end -module RuboCop::Rake -end -class RuboCop::Rake::Error < StandardError -end -module RuboCop::Rake::Inject - def self.defaults!; end -end -module RuboCop::Cop -end -module RuboCop::Cop::Rake -end -module RuboCop::Cop::Rake::Helper -end -module RuboCop::Cop::Rake::Helper::ClassDefinition - def class_definition?(param0 = nil); end - def in_class_definition?(node); end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::Cop::Rake::Helper::ClassDefinition -end -module RuboCop::Cop::Rake::Helper::OnTask - def on_send(node); end - def task?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::Rake::Helper::TaskDefinition - def in_task_or_namespace?(node); end - def task_or_namespace?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::Cop::Rake::Helper::TaskDefinition -end -module RuboCop::Cop::Rake::Helper::TaskName - def task_name(node); end - extend RuboCop::Cop::Rake::Helper::TaskName -end -module RuboCop::Cop::Rake::Helper::OnNamespace - def namespace?(param0 = nil); end - def on_send(node); end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::Rake::ClassDefinitionInTask < RuboCop::Cop::Base - def on_class(node); end - def on_module(node); end -end -class RuboCop::Cop::Rake::Desc < RuboCop::Cop::Base - def can_insert_desc_to?(parent); end - def on_task(node); end - def parent_and_task(task_node); end - def prerequisites(param0 = nil); end - def task_with_desc?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Rake::Helper::OnTask -end -class RuboCop::Cop::Rake::DuplicateTask < RuboCop::Cop::Base - def initialize(*arg0); end - def message_for_dup(previous:, current:, task_name:); end - def namespaces(node); end - def on_task(node); end - def source_location(node); end - include RuboCop::Cop::Rake::Helper::OnTask -end -class RuboCop::Cop::Rake::DuplicateNamespace < RuboCop::Cop::Base - def initialize(*arg0); end - def message_for_dup(previous:, current:, namespace:); end - def namespaces(node); end - def on_namespace(node); end - def source_location(node); end - include RuboCop::Cop::Rake::Helper::OnNamespace -end -class RuboCop::Cop::Rake::MethodDefinitionInTask < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end -end diff --git a/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi b/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi new file mode 100644 index 00000000..e4d9aeab --- /dev/null +++ b/sorbet/rbi/gems/rubocop-rake@0.6.0.rbi @@ -0,0 +1,347 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-rake` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-rake`. + +# source://rubocop-rake-0.6.0/lib/rubocop/rake/version.rb:3 +module RuboCop; end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:4 +module RuboCop::Cop; end + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:33 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:46 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:5 +module RuboCop::Cop::Rake; end + +# This cop detects class or module definition in a task or namespace, +# because it is defined to the top level. +# It is confusing because the scope looks in the task or namespace, +# but actually it is defined to the top level. +# +# @example +# # bad +# task :foo do +# class C +# end +# end +# +# # bad +# namespace :foo do +# module M +# end +# end +# +# # good - It is also defined to the top level, +# # but it looks expected behavior. +# class C +# end +# task :foo do +# end +# +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/class_definition_in_task.rb:31 +class RuboCop::Cop::Rake::ClassDefinitionInTask < ::RuboCop::Cop::Base + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/class_definition_in_task.rb:34 + def on_class(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/class_definition_in_task.rb:34 + def on_module(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/class_definition_in_task.rb:32 +RuboCop::Cop::Rake::ClassDefinitionInTask::MSG = T.let(T.unsafe(nil), String) + +# Rake task definition should have a description with `desc` method. +# It is useful as a documentation of task. And Rake does not display +# task that does not have `desc` by `rake -T`. +# +# Note: This cop does not require description for the default task, +# because the default task is executed with `rake` without command. +# +# @example +# # bad +# task :do_something +# +# # bad +# task :do_something do +# end +# +# # good +# desc 'Do something' +# task :do_something +# +# # good +# desc 'Do something' +# task :do_something do +# end +# +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:30 +class RuboCop::Cop::Rake::Desc < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Rake::Helper::OnTask + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:40 + def on_task(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:36 + def prerequisites(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:76 + def can_insert_desc_to?(parent); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:62 + def parent_and_task(task_node); end + + # @return [Boolean] + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:50 + def task_with_desc?(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/desc.rb:34 +RuboCop::Cop::Rake::Desc::MSG = T.let(T.unsafe(nil), String) + +# If namespaces are defined with the same name, Rake executes the both namespaces +# in definition order. +# It is redundant. You should squash them into one definition. +# This cop detects it. +# +# @example +# # bad +# namespace :foo do +# task :bar do +# end +# end +# namespace :foo do +# task :hoge do +# end +# end +# +# # good +# namespace :foo do +# task :bar do +# end +# task :hoge do +# end +# end +# +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:30 +class RuboCop::Cop::Rake::DuplicateNamespace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Rake::Helper::OnNamespace + + # @return [DuplicateNamespace] a new instance of DuplicateNamespace + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:35 + def initialize(*_arg0); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:67 + def message_for_dup(previous:, current:, namespace:); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:53 + def namespaces(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:40 + def on_namespace(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:76 + def source_location(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_namespace.rb:33 +RuboCop::Cop::Rake::DuplicateNamespace::MSG = T.let(T.unsafe(nil), String) + +# If tasks are defined with the same name, Rake executes the both tasks +# in definition order. +# It is misleading sometimes. You should squash them into one definition. +# This cop detects it. +# +# @example +# # bad +# task :foo do +# p 'foo 1' +# end +# task :foo do +# p 'foo 2' +# end +# +# # good +# task :foo do +# p 'foo 1' +# p 'foo 2' +# end +# +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:26 +class RuboCop::Cop::Rake::DuplicateTask < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Rake::Helper::OnTask + + # @return [DuplicateTask] a new instance of DuplicateTask + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:31 + def initialize(*_arg0); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:66 + def message_for_dup(previous:, current:, task_name:); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:52 + def namespaces(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:36 + def on_task(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:75 + def source_location(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/duplicate_task.rb:29 +RuboCop::Cop::Rake::DuplicateTask::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:6 +module RuboCop::Cop::Rake::Helper; end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:7 +module RuboCop::Cop::Rake::Helper::ClassDefinition + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::Cop::Rake::Helper::ClassDefinition + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:11 + def class_definition?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/class_definition.rb:22 + def in_class_definition?(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_namespace.rb:7 +module RuboCop::Cop::Rake::Helper::OnNamespace + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_namespace.rb:10 + def namespace?(param0 = T.unsafe(nil)); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_namespace.rb:14 + def on_send(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_task.rb:7 +module RuboCop::Cop::Rake::Helper::OnTask + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_task.rb:14 + def on_send(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/on_task.rb:10 + def task?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/task_definition.rb:7 +module RuboCop::Cop::Rake::Helper::TaskDefinition + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::Cop::Rake::Helper::TaskDefinition + + # @return [Boolean] + # + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/task_definition.rb:19 + def in_task_or_namespace?(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/task_definition.rb:11 + def task_or_namespace?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/task_name.rb:7 +module RuboCop::Cop::Rake::Helper::TaskName + extend ::RuboCop::Cop::Rake::Helper::TaskName + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/helper/task_name.rb:10 + def task_name(node); end +end + +# This cop detects method definition in a task or namespace, +# because it is defined to the top level. +# It is confusing because the scope looks in the task or namespace, +# but actually it is defined to the top level. +# +# @example +# # bad +# task :foo do +# def helper_method +# do_something +# end +# end +# +# # bad +# namespace :foo do +# def helper_method +# do_something +# end +# end +# +# # good - It is also defined to the top level, +# # but it looks expected behavior. +# def helper_method +# end +# task :foo do +# end +# +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/method_definition_in_task.rb:33 +class RuboCop::Cop::Rake::MethodDefinitionInTask < ::RuboCop::Cop::Base + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/method_definition_in_task.rb:36 + def on_def(node); end + + # source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/method_definition_in_task.rb:36 + def on_defs(node); end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/cop/rake/method_definition_in_task.rb:34 +RuboCop::Cop::Rake::MethodDefinitionInTask::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# source://rubocop-rake-0.6.0/lib/rubocop/rake/version.rb:4 +module RuboCop::Rake; end + +# source://rubocop-rake-0.6.0/lib/rubocop/rake.rb:12 +RuboCop::Rake::CONFIG = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rake-0.6.0/lib/rubocop/rake.rb:11 +RuboCop::Rake::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname) + +# source://rubocop-rake-0.6.0/lib/rubocop/rake.rb:8 +class RuboCop::Rake::Error < ::StandardError; end + +# Because RuboCop doesn't yet support plugins, we have to monkey patch in a +# bit of our configuration. +# +# source://rubocop-rake-0.6.0/lib/rubocop/rake/inject.rb:9 +module RuboCop::Rake::Inject + class << self + # source://rubocop-rake-0.6.0/lib/rubocop/rake/inject.rb:10 + def defaults!; end + end +end + +# source://rubocop-rake-0.6.0/lib/rubocop/rake.rb:10 +RuboCop::Rake::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname) + +# source://rubocop-rake-0.6.0/lib/rubocop/rake/version.rb:5 +RuboCop::Rake::VERSION = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token diff --git a/sorbet/rbi/gems/rubocop-rspec.rbi b/sorbet/rbi/gems/rubocop-rspec.rbi deleted file mode 100644 index 5a49d249..00000000 --- a/sorbet/rbi/gems/rubocop-rspec.rbi +++ /dev/null @@ -1,1085 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-rspec/all/rubocop-rspec.rbi -# -# rubocop-rspec-2.12.1 - -module RuboCop -end -module RuboCop::RSpec -end -module RuboCop::RSpec::Version -end -module RuboCop::RSpec::Inject - def self.defaults!; end -end -module RuboCop::RSpec::Node - def recursive_literal_or_const?; end -end -class RuboCop::RSpec::Wording - def append_suffix(word, suffix); end - def ignored_word?(word); end - def ignores; end - def initialize(text, ignore:, replace:); end - def remove_should_and_pluralize; end - def replace_prefix(pattern, replacement); end - def replacements; end - def rewrite; end - def substitute(word); end - def text; end - def uppercase?(word); end -end -module RuboCop::RSpec::Language - def example?(param0 = nil); end - def example_group?(param0 = nil); end - def example_group_with_body?(param0 = nil); end - def hook?(param0 = nil); end - def include?(param0 = nil); end - def let?(param0 = nil); end - def rspec?(param0 = nil); end - def self.config; end - def self.config=(arg0); end - def shared_group?(param0 = nil); end - def spec_group?(param0 = nil); end - def subject?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::RSpec::Language::NodePattern -end -module RuboCop::RSpec::Language::NodePattern - def block_pattern(string); end - def send_pattern(string); end -end -module RuboCop::RSpec::Language::ExampleGroups - def self.all(element); end - def self.focused(element); end - def self.regular(element); end - def self.skipped(element); end -end -module RuboCop::RSpec::Language::Examples - def self.all(element); end - def self.focused(element); end - def self.pending(element); end - def self.regular(element); end - def self.skipped(element); end -end -module RuboCop::RSpec::Language::Expectations - def self.all(element); end -end -module RuboCop::RSpec::Language::Helpers - def self.all(element); end -end -module RuboCop::RSpec::Language::Hooks - def self.all(element); end -end -module RuboCop::RSpec::Language::HookScopes - def self.all(element); end -end -module RuboCop::RSpec::Language::Includes - def self.all(element); end - def self.context(element); end - def self.examples(element); end -end -module RuboCop::RSpec::Language::Runners - def self.all(element); end -end -module RuboCop::RSpec::Language::SharedGroups - def self.all(element); end - def self.context(element); end - def self.examples(element); end -end -module RuboCop::RSpec::Language::Subjects - def self.all(element); end -end -module RuboCop::RSpec::Language::ALL - def self.all(element); end -end -module RuboCop::RSpec::FactoryBot - def self.attribute_defining_methods; end - def self.reserved_methods; end -end -module RuboCop::RSpec::FactoryBot::Language - def factory_bot?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop -end -module RuboCop::Cop::RSpec -end -module RuboCop::Cop::RSpec::TopLevelGroup - def on_new_investigation; end - def on_top_level_example_group(_node); end - def on_top_level_group(_node); end - def root_node; end - def top_level_group?(node); end - def top_level_groups; end - def top_level_nodes(node); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::RSpec::Variable - def variable_definition?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::RSpec::FinalEndLocation - def final_end_location(start_node); end -end -module RuboCop::Cop::RSpec::CommentsHelp - def begin_pos_with_comment(node); end - def buffer; end - def end_line_position(node); end - def source_range_with_comment(node); end - def start_line_position(node); end - include RuboCop::Cop::RSpec::FinalEndLocation -end -module RuboCop::Cop::RSpec::EmptyLineSeparation - def last_child?(node); end - def missing_separating_line(node); end - def missing_separating_line_offense(node); end - def offending_loc(last_line); end - include RuboCop::Cop::RSpec::FinalEndLocation - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::RSpec::InsideExampleGroup - def example_group_root?(node); end - def example_group_root_with_siblings?(node); end - def inside_example_group?(node); end -end -class RuboCop::RSpec::Concept - def ==(other); end - def eql?(other); end - def hash; end - def initialize(node); end - def node; end - def to_node; end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::RSpec::Language::NodePattern - include RuboCop::RSpec::Language -end -class RuboCop::RSpec::ExampleGroup < RuboCop::RSpec::Concept - def examples; end - def find_all(node, predicate); end - def find_all_in_scope(node, predicate); end - def hooks; end - def lets; end - def scope_change?(param0 = nil); end - def subjects; end -end -class RuboCop::RSpec::Example < RuboCop::RSpec::Concept - def definition; end - def doc_string; end - def extract_doc_string(param0 = nil); end - def extract_implementation(param0 = nil); end - def extract_metadata(param0 = nil); end - def implementation; end - def metadata; end -end -class RuboCop::RSpec::Hook < RuboCop::RSpec::Concept - def example?; end - def extract_metadata(param0 = nil); end - def knowable_scope?; end - def metadata; end - def name; end - def scope; end - def scope_argument; end - def scope_name; end - def transform_metadata(meta); end - def transform_true(node); end - def valid_scope?(node); end -end -class RuboCop::Cop::RSpec::Base < RuboCop::Cop::Base - def on_new_investigation; end - def self.inherited(subclass); end - extend RuboCop::RSpec::Language::NodePattern - include RuboCop::RSpec::Language -end -class RuboCop::RSpec::AlignLetBrace - def adjacent_let_chunks; end - def indent_for(node); end - def initialize(root, token); end - def let_group_for(let); end - def let_token(node); end - def offending_tokens; end - def root; end - def single_line_lets; end - def target_column_for(let); end - def token; end - include RuboCop::Cop::Util - include RuboCop::RSpec::Language -end -module RuboCop::RSpec::Corrector -end -class RuboCop::RSpec::Corrector::MoveNode - def corrector; end - def initialize(node, corrector, processed_source); end - def move_after(other); end - def move_before(other); end - def node_range(node); end - def node_range_with_surrounding_space(node); end - def original; end - def processed_source; end - def source(node); end - include RuboCop::Cop::RSpec::CommentsHelp - include RuboCop::Cop::RSpec::FinalEndLocation - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::RSpec::Capybara -end -class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < RuboCop::Cop::RSpec::Base - def add_ignore_query_options(corrector, node); end - def as_is_matcher(param0 = nil); end - def autocorrect(corrector, node); end - def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str); end - def expectation_set_on_current_path(param0 = nil); end - def on_send(node); end - def regexp_str_matcher(param0 = nil); end - def rewrite_expectation(corrector, node, to_symbol, matcher_node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::Capybara::FeatureMethods < RuboCop::Cop::RSpec::Base - def capybara_speak(param0 = nil); end - def enabled?(method_name); end - def enabled_methods; end - def feature_method(param0 = nil); end - def message(range); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::InsideExampleGroup -end -class RuboCop::Cop::RSpec::Capybara::SpecificMatcher < RuboCop::Cop::RSpec::Base - def acceptable_pattern?(arg); end - def first_argument(param0 = nil); end - def good_matcher(node, matcher); end - def message(node, matcher); end - def on_send(node); end - def specific_matcher(arg); end -end -class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < RuboCop::Cop::RSpec::Base - def capybara_matcher?(method_name); end - def on_send(node); end - def visible_false?(param0 = nil); end - def visible_true?(param0 = nil); end -end -module RuboCop::Cop::RSpec::FactoryBot -end -class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < RuboCop::Cop::RSpec::Base - def association?(param0 = nil); end - def attribute_defining_method?(method_name); end - def autocorrect(corrector, node); end - def autocorrect_replacing_parens(corrector, node); end - def autocorrect_without_parens(corrector, node); end - def braces(node); end - def factory_attributes(param0 = nil); end - def offensive_receiver?(receiver, node); end - def on_block(node); end - def proc?(attribute); end - def receiver_matches_first_block_argument?(receiver, node); end - def reserved_method?(method_name); end - def value_hash_without_braces?(node); end - def value_matcher(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::FactoryBot::CreateList < RuboCop::Cop::RSpec::Base - def arguments_include_method_call?(param0 = nil); end - def contains_only_factory?(node); end - def factory_call(param0 = nil); end - def factory_list_call(param0 = nil); end - def n_times_block?(param0 = nil); end - def n_times_block_with_arg_and_used?(param0 = nil); end - def on_block(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::RSpec::FactoryBot::Language -end -module RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector - def build_options_string(options); end - def format_method_call(node, method, arguments); end - def format_receiver(receiver); end -end -class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector - def call(corrector); end - def generate_n_times_block(node); end - def initialize(node); end - def node; end - include RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector -end -class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector - def build_arguments(node, count); end - def call(corrector); end - def call_replacement(node); end - def call_with_block_replacement(node); end - def format_block(node); end - def format_multiline_block(node); end - def format_singleline_block(node); end - def initialize(node); end - def node; end - include RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector -end -class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < RuboCop::Cop::RSpec::Base - def allowed?(const_name); end - def class_name(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods < RuboCop::Cop::RSpec::Base - def crime_scene(node); end - def offense(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::InsideExampleGroup - include RuboCop::Cop::RangeHelp - include RuboCop::RSpec::FactoryBot::Language -end -module RuboCop::Cop::RSpec::Rails -end -class RuboCop::Cop::RSpec::Rails::AvoidSetupHook < RuboCop::Cop::RSpec::Base - def on_block(node); end - def setup_call(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::Rails::HaveHttpStatus < RuboCop::Cop::RSpec::Base - def match_status(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::AlignLeftLetBrace < RuboCop::Cop::RSpec::Base - def on_new_investigation; end - def self.autocorrect_incompatible_with; end - def token_aligner; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::AlignRightLetBrace < RuboCop::Cop::RSpec::Base - def on_new_investigation; end - def self.autocorrect_incompatible_with; end - def token_aligner; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::AnyInstance < RuboCop::Cop::RSpec::Base - def on_send(node); end -end -class RuboCop::Cop::RSpec::AroundBlock < RuboCop::Cop::RSpec::Base - def add_no_arg_offense(node); end - def check_for_unused_proxy(block, proxy); end - def find_arg_usage(param0); end - def hook(param0 = nil); end - def on_block(node); end -end -class RuboCop::Cop::RSpec::Be < RuboCop::Cop::RSpec::Base - def be_without_args(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::BeEq < RuboCop::Cop::RSpec::Base - def eq_type_with_identity?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::BeEql < RuboCop::Cop::RSpec::Base - def eql_type_with_identity(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::BeNil < RuboCop::Cop::RSpec::Base - def be_nil_matcher?(param0 = nil); end - def check_be_nil_style(node); end - def check_be_style(node); end - def nil_value_expectation?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::BeforeAfterAll < RuboCop::Cop::RSpec::Base - def before_or_after_all(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::ChangeByZero < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node); end - def check_offense(node); end - def compound_expectations?(node); end - def expect_change_with_arguments(param0 = nil); end - def expect_change_with_block(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ContextMethod < RuboCop::Cop::RSpec::Base - def context_method(param0 = nil); end - def method_name?(description); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ContextWording < RuboCop::Cop::RSpec::Base - def bad_prefix?(description); end - def context_wording(param0 = nil); end - def joined_prefixes; end - def on_block(node); end - def prefix_regex; end - def prefixes; end -end -class RuboCop::Cop::RSpec::DescribeClass < RuboCop::Cop::RSpec::Base - def example_group_with_ignored_metadata?(param0 = nil); end - def ignored_metadata; end - def ignored_metadata?(node); end - def not_a_const_described(param0 = nil); end - def on_top_level_group(node); end - def string_constant?(described); end - def sym_pair(param0 = nil); end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::DescribeMethod < RuboCop::Cop::RSpec::Base - def on_top_level_group(node); end - def second_argument(param0 = nil); end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::DescribeSymbol < RuboCop::Cop::RSpec::Base - def describe_symbol?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::DescribedClass < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, match); end - def collapse_namespace(namespace, const); end - def common_instance_exec_closure?(param0 = nil); end - def const_name(node); end - def contains_described_class?(param0); end - def described_constant(param0 = nil); end - def find_usage(node, &block); end - def full_const_name(node); end - def message(offense); end - def namespace(node); end - def offensive?(node); end - def offensive_described_class?(node); end - def on_block(node); end - def rspec_block?(param0 = nil); end - def scope_change?(node); end - def scope_changing_syntax?(param0 = nil); end - def skippable_block?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < RuboCop::Cop::RSpec::Base - def find_rspec_blocks(param0); end - def on_module(node); end -end -class RuboCop::Cop::RSpec::Dialect < RuboCop::Cop::RSpec::Base - def on_send(node); end - def rspec_method?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MethodPreference -end -class RuboCop::Cop::RSpec::EmptyExampleGroup < RuboCop::Cop::RSpec::Base - def conditionals_with_examples?(body); end - def example_group_body(param0 = nil); end - def example_or_group_or_include?(param0 = nil); end - def examples?(param0 = nil); end - def examples_directly_or_in_block?(param0 = nil); end - def examples_in_branches?(condition_node); end - def examples_inside_block?(param0 = nil); end - def offensive?(body); end - def on_block(node); end -end -class RuboCop::Cop::RSpec::EmptyHook < RuboCop::Cop::RSpec::Base - def empty_hook?(param0 = nil); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::RSpec::EmptyLineAfterExample < RuboCop::Cop::RSpec::Base - def allow_consecutive_one_liners?; end - def allowed_one_liner?(node); end - def consecutive_one_liner?(node); end - def next_one_line_example?(node); end - def next_sibling(node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::EmptyLineSeparation -end -class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < RuboCop::Cop::RSpec::Base - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::EmptyLineSeparation -end -class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < RuboCop::Cop::RSpec::Base - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::EmptyLineSeparation -end -class RuboCop::Cop::RSpec::EmptyLineAfterHook < RuboCop::Cop::RSpec::Base - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::EmptyLineSeparation -end -class RuboCop::Cop::RSpec::EmptyLineAfterSubject < RuboCop::Cop::RSpec::Base - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::EmptyLineSeparation - include RuboCop::Cop::RSpec::InsideExampleGroup -end -class RuboCop::Cop::RSpec::ExampleLength < RuboCop::Cop::RSpec::Base - def cop_label; end - def on_block(node); end - include RuboCop::Cop::CodeLength -end -class RuboCop::Cop::RSpec::ExampleWithoutDescription < RuboCop::Cop::RSpec::Base - def check_example_without_description(node); end - def disallow_empty_description?(node); end - def example_description(param0 = nil); end - def on_block(node); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::ExampleWording < RuboCop::Cop::RSpec::Base - def add_wording_offense(node, message); end - def custom_transform; end - def docstring(node); end - def ignored_words; end - def it_description(param0 = nil); end - def on_block(node); end - def replacement_text(node); end - def text(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < RuboCop::Cop::RSpec::Base - def add_whitespace_offense(node, text); end - def docstring(node); end - def example_description(param0 = nil); end - def excessive_whitespace?(text); end - def on_send(node); end - def strip_excessive_whitespace(text); end - def text(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ExpectActual < RuboCop::Cop::RSpec::Base - def complex_literal?(node); end - def expect_literal(param0 = nil); end - def literal?(node); end - def on_send(node); end - def simple_literal?(node); end - def swap(corrector, actual, expected); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ExpectChange < RuboCop::Cop::RSpec::Base - def expect_change_with_arguments(param0 = nil); end - def expect_change_with_block(param0 = nil); end - def on_block(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::ExpectInHook < RuboCop::Cop::RSpec::Base - def expectation(param0); end - def message(expect, hook); end - def on_block(node); end -end -class RuboCop::Cop::RSpec::ExpectOutput < RuboCop::Cop::RSpec::Base - def inside_example_scope?(node); end - def on_gvasgn(node); end -end -class RuboCop::Cop::RSpec::FilePath < RuboCop::Cop::RSpec::Base - def camel_to_snake_case(string); end - def custom_transform; end - def ensure_correct_file_path(send_node, example_group, arguments); end - def example_group(param0 = nil); end - def expected_path(constant); end - def filename_ends_with?(pattern); end - def ignore_methods?; end - def name_pattern(method_name); end - def on_top_level_example_group(node); end - def pattern_for(example_group, method_name); end - def pattern_for_spec_suffix_only?; end - def relevant_rubocop_rspec_file?(_file); end - def routing_metadata?(param0); end - def routing_spec?(args); end - def spec_suffix_only?; end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::Focus < RuboCop::Cop::RSpec::Base - def correct_send(corrector, focus); end - def focus_metadata(node, &block); end - def focusable_selector?(param0 = nil); end - def focused_block?(param0 = nil); end - def metadata(param0 = nil); end - def on_send(node); end - def with_surrounding(focus); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::RSpec::HookArgument < RuboCop::Cop::RSpec::Base - def argument_range(send_node); end - def check_implicit(method_send); end - def explicit_message(scope); end - def hook(node, &block); end - def implicit_style?; end - def on_block(node); end - def scoped_hook(param0 = nil); end - def unscoped_hook(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::HooksBeforeExamples < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, first_example); end - def check_hooks(node); end - def example_or_group?(param0 = nil); end - def find_first_example(node); end - def multiline_block?(block); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < RuboCop::Cop::RSpec::Base - def equality_check?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::ImplicitBlockExpectation < RuboCop::Cop::RSpec::Base - def find_subject(block_node); end - def implicit_expect(param0 = nil); end - def lambda?(param0 = nil); end - def lambda_subject?(param0 = nil); end - def multi_statement_example_group?(node); end - def nearest_subject(node); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::ImplicitExpect < RuboCop::Cop::RSpec::Base - def implicit_expect(param0 = nil); end - def is_expected_range(source_map); end - def offending_expect(node); end - def offense_message(offending_source); end - def on_send(node); end - def replacement_source(offending_source); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::ImplicitSubject < RuboCop::Cop::RSpec::Base - def allowed_by_style?(example); end - def autocorrect(corrector, node); end - def implicit_subject?(param0 = nil); end - def on_send(node); end - def valid_usage?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::InstanceSpy < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node); end - def have_received_usage(param0); end - def null_double(param0); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::InstanceVariable < RuboCop::Cop::RSpec::Base - def assignment_only?; end - def custom_matcher?(param0 = nil); end - def dynamic_class?(param0 = nil); end - def ivar_assigned?(param0, param1); end - def ivar_usage(param0); end - def on_top_level_group(node); end - def valid_usage?(node); end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::ItBehavesLike < RuboCop::Cop::RSpec::Base - def example_inclusion_offense(param0 = nil, param1); end - def message(_node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::IteratedExpectation < RuboCop::Cop::RSpec::Base - def each?(param0 = nil); end - def expectation?(param0 = nil, param1); end - def on_block(node); end - def only_expectations?(body, arg); end - def single_expectation?(body, arg); end -end -class RuboCop::Cop::RSpec::LeadingSubject < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, sibling); end - def check_previous_nodes(node); end - def offending?(node); end - def offending_node(node); end - def on_block(node); end - def parent(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RSpec::InsideExampleGroup -end -class RuboCop::Cop::RSpec::LeakyConstantDeclaration < RuboCop::Cop::RSpec::Base - def inside_describe_block?(node); end - def on_casgn(node); end - def on_class(node); end - def on_module(node); end -end -class RuboCop::Cop::RSpec::LetBeforeExamples < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, first_example); end - def check_let_declarations(node); end - def example_or_group?(param0 = nil); end - def find_first_example(node); end - def multiline_block?(block); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::LetSetup < RuboCop::Cop::RSpec::Base - def child_let_bang(node, &block); end - def example_or_shared_group_or_including?(param0 = nil); end - def let_bang(param0 = nil); end - def method_called?(param0, param1); end - def on_block(node); end - def unused_let_bang(node); end -end -class RuboCop::Cop::RSpec::MessageChain < RuboCop::Cop::RSpec::Base - def on_send(node); end -end -class RuboCop::Cop::RSpec::MessageExpectation < RuboCop::Cop::RSpec::Base - def message_expectation(param0 = nil); end - def on_send(node); end - def preferred_style?(expectation); end - def receive_message?(param0); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::MessageSpies < RuboCop::Cop::RSpec::Base - def error_message(receiver); end - def message_expectation(param0 = nil); end - def on_send(node); end - def preferred_style?(expectation); end - def receive_message(param0); end - def receive_message_matcher(node); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::MissingExampleGroupArgument < RuboCop::Cop::RSpec::Base - def on_block(node); end -end -class RuboCop::Cop::RSpec::MultipleDescribes < RuboCop::Cop::RSpec::Base - def on_top_level_group(node); end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::MultipleExpectations < RuboCop::Cop::RSpec::Base - def aggregate_failures?(param0 = nil, param1); end - def aggregate_failures_block?(param0 = nil); end - def example_with_aggregate_failures?(example_node); end - def expect?(param0 = nil); end - def find_aggregate_failures(example_node); end - def find_expectation(node, &block); end - def flag_example(node, expectation_count:); end - def max_expectations; end - def on_block(node); end - include RuboCop::Cop::ConfigurableMax -end -class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < RuboCop::Cop::RSpec::Base - def all_helpers(node); end - def allow_subject?; end - def example_group_memoized_helpers; end - def helpers(node); end - def max; end - def on_block(node); end - def on_new_investigation; end - def variable_nodes(node); end - include RuboCop::Cop::ConfigurableMax - include RuboCop::Cop::RSpec::Variable -end -class RuboCop::Cop::RSpec::MultipleSubjects < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, subject); end - def named_subject?(node); end - def on_block(node); end - def remove_autocorrect(corrector, node); end - def rename_autocorrect(corrector, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::RSpec::NamedSubject < RuboCop::Cop::RSpec::Base - def example_or_hook_block?(param0 = nil); end - def ignored_shared_example?(node); end - def on_block(node); end - def shared_example?(param0 = nil); end - def subject_usage(param0); end -end -class RuboCop::Cop::RSpec::NestedGroups < RuboCop::Cop::RSpec::Base - def find_nested_example_groups(node, nesting: nil, &block); end - def max_nesting; end - def max_nesting_config; end - def message(nesting); end - def on_top_level_group(node); end - include RuboCop::Cop::ConfigurableMax - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::NotToNot < RuboCop::Cop::RSpec::Base - def message(_node); end - def not_to_not_offense(param0 = nil, param1); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::OverwritingSetup < RuboCop::Cop::RSpec::Base - def common_setup?(node); end - def find_duplicates(node); end - def first_argument_name(param0 = nil); end - def on_block(node); end - def setup?(param0 = nil); end -end -class RuboCop::Cop::RSpec::Pending < RuboCop::Cop::RSpec::Base - def on_send(node); end - def pending_block?(param0 = nil); end - def skip_or_pending?(param0 = nil); end - def skippable?(param0 = nil); end - def skipped?(node); end - def skipped_in_metadata?(param0 = nil); end -end -module RuboCop::Cop::RSpec::InflectedHelper - def be_bool?(param0 = nil); end - def be_boolthy?(param0 = nil); end - def boolean_matcher?(node); end - def check_inflected(node); end - def message_inflected(predicate); end - def predicate?(sym); end - def predicate_in_actual?(param0 = nil); end - def remove_predicate(corrector, predicate); end - def rewrite_matcher(corrector, predicate, matcher); end - def to_predicate_matcher(name); end - def true?(to_symbol, matcher); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::RSpec::Language -end -module RuboCop::Cop::RSpec::ExplicitHelper - def allowed_explicit_matchers; end - def check_explicit(node); end - def corrector_explicit(corrector, to_node, actual, matcher, block_child); end - def message_explicit(matcher); end - def move_predicate(corrector, actual, matcher, block_child); end - def predicate_matcher?(param0 = nil); end - def predicate_matcher_block?(param0 = nil); end - def predicate_matcher_name?(name); end - def replacement_matcher(node); end - def to_predicate_method(matcher); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::RSpec::Language -end -class RuboCop::Cop::RSpec::PredicateMatcher < RuboCop::Cop::RSpec::Base - def args_loc(send_node); end - def block_loc(send_node); end - def on_block(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RSpec::ExplicitHelper - include RuboCop::Cop::RSpec::InflectedHelper -end -class RuboCop::Cop::RSpec::ReceiveCounts < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, range); end - def matcher_for(method, count); end - def message_for(node, source); end - def on_send(node); end - def range(node, offending_node); end - def receive_counts(param0 = nil); end - def stub?(param0); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ReceiveNever < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node); end - def method_on_stub?(param0); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::RepeatedDescription < RuboCop::Cop::RSpec::Base - def example_signature(example); end - def on_block(node); end - def repeated_descriptions(node); end -end -class RuboCop::Cop::RSpec::RepeatedExample < RuboCop::Cop::RSpec::Base - def example_signature(example); end - def on_block(node); end - def repeated_examples(node); end -end -class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < RuboCop::Cop::RSpec::Base - def add_repeated_lines(groups); end - def body(param0 = nil); end - def const_arg(param0 = nil); end - def message(group, repeats); end - def metadata(param0 = nil); end - def on_begin(node); end - def repeated_group_bodies(node); end - def several_example_groups?(param0 = nil); end - def signature_keys(group); end - def skip_or_pending?(param0 = nil); end -end -class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < RuboCop::Cop::RSpec::Base - def add_repeated_lines(groups); end - def doc_string_and_metadata(param0 = nil); end - def empty_description?(param0 = nil); end - def message(group, repeats); end - def on_begin(node); end - def repeated_group_descriptions(node); end - def several_example_groups?(param0 = nil); end - def skip_or_pending?(param0 = nil); end -end -class RuboCop::Cop::RSpec::RepeatedIncludeExample < RuboCop::Cop::RSpec::Base - def add_repeated_lines(items); end - def include_examples?(param0 = nil); end - def literal_include_examples?(node); end - def message(item, repeats); end - def on_begin(node); end - def repeated_include_examples(node); end - def several_include_examples?(param0 = nil); end - def shared_examples_name(param0 = nil); end - def signature_keys(item); end -end -class RuboCop::Cop::RSpec::ReturnFromStub < RuboCop::Cop::RSpec::Base - def and_return_value(param0); end - def check_and_return_call(node); end - def check_block_body(block); end - def contains_stub?(param0); end - def dynamic?(node); end - def on_block(node); end - def on_send(node); end - def stub_with_block?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector - def arg; end - def call(corrector); end - def hash_without_braces?; end - def heredoc?; end - def initialize(node); end - def node; end - def range; end - def receiver; end - def replacement; end -end -class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector - def block; end - def body; end - def call(corrector); end - def heredoc?; end - def initialize(block); end - def node; end -end -class RuboCop::Cop::RSpec::ScatteredLet < RuboCop::Cop::RSpec::Base - def check_let_declarations(body); end - def find_first_let(node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::ScatteredSetup < RuboCop::Cop::RSpec::Base - def lines_msg(numbers); end - def on_block(node); end - def repeated_hooks(node); end -end -class RuboCop::Cop::RSpec::SharedContext < RuboCop::Cop::RSpec::Base - def context?(param0); end - def context_with_only_examples(node); end - def examples?(param0); end - def examples_with_only_context(node); end - def on_block(node); end - def shared_context(param0 = nil); end - def shared_example(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::SharedExamples < RuboCop::Cop::RSpec::Base - def on_send(node); end - def shared_examples(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::SharedExamples::Checker - def initialize(node); end - def message; end - def node; end - def preferred_style; end - def symbol; end - def wrap_with_single_quotes(string); end -end -class RuboCop::Cop::RSpec::SingleArgumentMessageChain < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, method, arg); end - def autocorrect_array_arg(corrector, arg); end - def autocorrect_hash_arg(corrector, arg); end - def key_to_arg(node); end - def message_chain(param0 = nil); end - def on_send(node); end - def replacement(method); end - def single_element_array?(node); end - def single_key_hash?(param0 = nil); end - def valid_usage?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::RSpec::StubbedMock < RuboCop::Cop::RSpec::Base - def configured_response?(param0 = nil); end - def expectation(param0 = nil); end - def matcher_with_blockpass(param0 = nil); end - def matcher_with_configured_response(param0 = nil); end - def matcher_with_hash(param0 = nil); end - def matcher_with_return_block(param0 = nil); end - def message_expectation?(param0 = nil); end - def msg(method_name); end - def on_expectation(expectation, method_name, matcher); end - def on_send(node); end - def replacement(method_name); end -end -class RuboCop::Cop::RSpec::SubjectDeclaration < RuboCop::Cop::RSpec::Base - def message_for(offense); end - def offensive_subject_declaration?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::SubjectStub < RuboCop::Cop::RSpec::Base - def find_all_explicit(node); end - def find_subject_expectations(node, subject_names = nil, &block); end - def let?(param0 = nil); end - def message_expectation?(param0 = nil, param1); end - def message_expectation_matcher?(param0); end - def on_top_level_group(node); end - def subject?(param0 = nil); end - include RuboCop::Cop::RSpec::TopLevelGroup -end -class RuboCop::Cop::RSpec::UnspecifiedException < RuboCop::Cop::RSpec::Base - def block_with_args?(node); end - def empty_exception_matcher?(node); end - def empty_raise_error_or_exception(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::RSpec::VariableDefinition < RuboCop::Cop::RSpec::Base - def correct_variable(variable); end - def on_send(node); end - def string?(node); end - def style_violation?(variable); end - def symbol?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RSpec::Variable -end -class RuboCop::Cop::RSpec::VariableName < RuboCop::Cop::RSpec::Base - def message(style); end - def on_send(node); end - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::ConfigurableNaming - include RuboCop::Cop::RSpec::Variable -end -class RuboCop::Cop::RSpec::VerifiedDoubleReference < RuboCop::Cop::RSpec::Base - def correct_style(violation); end - def on_send(node); end - def opposing_style?(class_reference); end - def verified_double(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::RSpec::VerifiedDoubles < RuboCop::Cop::RSpec::Base - def on_send(node); end - def symbol?(name); end - def unverified_double(param0 = nil); end -end -class RuboCop::Cop::RSpec::VoidExpect < RuboCop::Cop::RSpec::Base - def check_expect(node); end - def expect?(param0 = nil); end - def expect_block?(param0 = nil); end - def on_block(node); end - def on_send(node); end - def void?(expect); end -end -class RuboCop::Cop::RSpec::Yield < RuboCop::Cop::RSpec::Base - def autocorrect(corrector, node, range); end - def block_arg(param0 = nil); end - def block_call?(param0 = nil, param1); end - def block_range(node); end - def calling_block?(node, block); end - def convert_block_to_yield(node); end - def generate_replacement(node); end - def method_on_stub?(param0); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::AST::Node < Parser::AST::Node - include RuboCop::RSpec::Node -end diff --git a/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi b/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi new file mode 100644 index 00000000..3d82c391 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-rspec@2.12.1.rbi @@ -0,0 +1,6541 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-rspec` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-rspec`. + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb:3 +module RuboCop; end + +class RuboCop::AST::Node < ::Parser::AST::Node + include ::RuboCop::RSpec::Node +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:4 +module RuboCop::Cop; end + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:33 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:46 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:5 +module RuboCop::Cop::RSpec; end + +# Checks that left braces for adjacent single line lets are aligned. +# +# @example +# +# # bad +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# # good +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb:20 +class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb:29 + def on_new_investigation; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb:44 + def token_aligner; end + + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb:25 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_left_let_brace.rb:23 +RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String) + +# Checks that right braces for adjacent single line lets are aligned. +# +# @example +# +# # bad +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# # good +# let(:foobar) { blahblah } +# let(:baz) { bar } +# let(:a) { b } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb:20 +class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb:29 + def on_new_investigation; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb:44 + def token_aligner; end + + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb:25 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/align_right_let_brace.rb:23 +RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String) + +# Check that instances are not being stubbed globally. +# +# Prefer instance doubles over stubbing any instance of a class +# +# @example +# # bad +# describe MyClass do +# before { allow_any_instance_of(MyClass).to receive(:foo) } +# end +# +# # good +# describe MyClass do +# let(:my_instance) { instance_double(MyClass) } +# +# before do +# allow(MyClass).to receive(:new).and_return(my_instance) +# allow(my_instance).to receive(:foo) +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb:25 +class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb:33 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb:26 +RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/any_instance.rb:27 +RuboCop::Cop::RSpec::AnyInstance::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that around blocks actually run the test. +# +# @example +# # bad +# around do +# some_method +# end +# +# around do |test| +# some_method +# end +# +# # good +# around do |test| +# some_method +# test.call +# end +# +# around do |test| +# some_method +# test.run +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:28 +class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:39 + def find_arg_usage(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:34 + def hook(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:43 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:55 + def add_no_arg_offense(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:59 + def check_for_unused_proxy(block, proxy); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:29 +RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/around_block.rb:30 +RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String) + +# @abstract parent class to RSpec cops +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb:7 +class RuboCop::Cop::RSpec::Base < ::RuboCop::Cop::Base + include ::RuboCop::RSpec::Language + extend ::RuboCop::RSpec::Language::NodePattern + + # Set the config for dynamic DSL configuration-aware helpers + # that have no other means of accessing the configuration. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb:20 + def on_new_investigation; end + + class << self + # Invoke the original inherited hook so our cops are recognized + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/base.rb:14 + def inherited(subclass); end + end +end + +# Check for expectations where `be` is used without argument. +# +# The `be` matcher is too generic, as it pass on everything that is not +# nil or false. If that is the exact intend, use `be_truthy`. In all other +# cases it's better to specify what exactly is the expected value. +# +# @example +# +# # bad +# expect(foo).to be +# +# # good +# expect(foo).to be_truthy +# expect(foo).to be 1.0 +# expect(foo).to be(true) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb:22 +class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb:26 + def be_without_args(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb:30 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be.rb:23 +RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String) + +# Check for expectations where `be(...)` can replace `eq(...)`. +# +# The `be` matcher compares by identity while the `eq` matcher compares +# using `==`. Booleans and nil can be compared by identity and therefore +# the `be` matcher is preferable as it is a more strict test. +# +# @example +# +# # bad +# expect(foo).to eq(true) +# expect(foo).to eq(false) +# expect(foo).to eq(nil) +# +# # good +# expect(foo).to be(true) +# expect(foo).to be(false) +# expect(foo).to be(nil) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb:24 +class RuboCop::Cop::RSpec::BeEq < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb:31 + def eq_type_with_identity?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb:35 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb:27 +RuboCop::Cop::RSpec::BeEq::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eq.rb:28 +RuboCop::Cop::RSpec::BeEq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for expectations where `be(...)` can replace `eql(...)`. +# +# The `be` matcher compares by identity while the `eql` matcher +# compares using `eql?`. Integers, floats, booleans, symbols, and nil +# can be compared by identity and therefore the `be` matcher is +# preferable as it is a more strict test. +# +# This cop only looks for instances of `expect(...).to eql(...)`. We +# do not check `to_not` or `not_to` since `!eql?` is more strict +# than `!equal?`. We also do not try to flag `eq` because if +# `a == b`, and `b` is comparable by identity, `a` is still not +# necessarily the same type as `b` since the `#==` operator can +# coerce objects for comparison. +# +# @example +# +# # bad +# expect(foo).to eql(1) +# expect(foo).to eql(1.0) +# expect(foo).to eql(true) +# expect(foo).to eql(false) +# expect(foo).to eql(:bar) +# expect(foo).to eql(nil) +# +# # good +# expect(foo).to be(1) +# expect(foo).to be(1.0) +# expect(foo).to be(true) +# expect(foo).to be(false) +# expect(foo).to be(:bar) +# expect(foo).to be(nil) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb:38 +class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb:45 + def eql_type_with_identity(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb:49 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb:41 +RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_eql.rb:42 +RuboCop::Cop::RSpec::BeEql::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Ensures a consistent style is used when matching `nil`. +# +# You can either use the more specific `be_nil` matcher, or the more +# generic `be` matcher with a `nil` argument. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: be_nil` (default) +# # bad +# expect(foo).to be(nil) +# +# # good +# expect(foo).to be_nil +# @example `EnforcedStyle: be` +# # bad +# expect(foo).to be_nil +# +# # good +# expect(foo).to be(nil) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:27 +class RuboCop::Cop::RSpec::BeNil < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:36 + def be_nil_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:41 + def nil_value_expectation?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:45 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:64 + def check_be_nil_style(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:56 + def check_be_style(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:31 +RuboCop::Cop::RSpec::BeNil::BE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:32 +RuboCop::Cop::RSpec::BeNil::BE_NIL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/be_nil.rb:33 +RuboCop::Cop::RSpec::BeNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that before/after(:all) isn't being used. +# +# @example +# # bad +# # +# # Faster but risk of state leaking between examples +# # +# describe MyClass do +# before(:all) { Widget.create } +# after(:all) { Widget.delete_all } +# end +# +# # good +# # +# # Slower but examples are properly isolated +# # +# describe MyClass do +# before(:each) { Widget.create } +# after(:each) { Widget.delete_all } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb:26 +class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb:35 + def before_or_after_all(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb:39 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb:27 +RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/before_after_all.rb:32 +RuboCop::Cop::RSpec::BeforeAfterAll::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:6 +module RuboCop::Cop::RSpec::Capybara; end + +# Checks that no expectations are set on Capybara's `current_path`. +# +# The +# https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher] +# should be used on `page` to set expectations on Capybara's +# current path, since it uses +# https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality] +# which ensures that preceding actions (like `click_link`) have +# completed. +# +# @example +# # bad +# expect(current_path).to eq('/callback') +# expect(page.current_path).to match(/widgets/) +# +# # good +# expect(page).to have_current_path("/callback") +# expect(page).to have_current_path(/widgets/) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:26 +class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # Supported matchers: eq(...) / match(/regexp/) / match('regexp') + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:42 + def as_is_matcher(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:36 + def expectation_set_on_current_path(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:59 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:49 + def regexp_str_matcher(param0 = T.unsafe(nil)); end + + private + + # `have_current_path` with no options will include the querystring + # while `page.current_path` does not. + # This ensures the option `ignore_query: true` is added + # except when the expectation is a regexp or string + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:105 + def add_ignore_query_options(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:71 + def autocorrect(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:95 + def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:82 + def rewrite_expectation(corrector, node, to_symbol, matcher_node); end + + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:55 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:29 +RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb:33 +RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for consistent method usage in feature specs. +# +# By default, the cop disables all Capybara-specific methods that have +# the same native RSpec method (e.g. are just aliases). Some teams +# however may prefer using some of the Capybara methods (like `feature`) +# to make it obvious that the test uses Capybara, while still disable +# the rest of the methods, like `given` (alias for `let`), `background` +# (alias for `before`), etc. You can configure which of the methods to +# be enabled by using the EnabledMethods configuration option. +# +# @example +# # bad +# feature 'User logs in' do +# given(:user) { User.new } +# +# background do +# visit new_session_path +# end +# +# scenario 'with OAuth' do +# # ... +# end +# end +# +# # good +# describe 'User logs in' do +# let(:user) { User.new } +# +# before do +# visit new_session_path +# end +# +# it 'with OAuth' do +# # ... +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:43 +class RuboCop::Cop::RSpec::Capybara::FeatureMethods < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:60 + def capybara_speak(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:65 + def feature_method(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:83 + def message(range); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:71 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:90 + def enabled?(method_name); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:94 + def enabled_methods; end +end + +# https://github.com/teamcapybara/capybara/blob/e283c1aeaa72441f5403963577e16333bf111a81/lib/capybara/rspec/features.rb#L31-L36 +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:50 +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MAP = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/feature_methods.rb:47 +RuboCop::Cop::RSpec::Capybara::FeatureMethods::MSG = T.let(T.unsafe(nil), String) + +# Checks for there is a more specific matcher offered by Capybara. +# +# @example +# +# # bad +# expect(page).to have_selector('button') +# expect(page).to have_no_selector('button.cls') +# expect(page).to have_css('button') +# expect(page).to have_no_css('a.cls', exact_text: 'foo') +# expect(page).to have_css('table.cls') +# expect(page).to have_css('select') +# +# # good +# expect(page).to have_button +# expect(page).to have_no_button(class: 'cls') +# expect(page).to have_button +# expect(page).to have_no_link('foo', class: 'cls') +# expect(page).to have_table(class: 'cls') +# expect(page).to have_select +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:27 +class RuboCop::Cop::RSpec::Capybara::SpecificMatcher < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:39 + def first_argument(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:43 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:58 + def acceptable_pattern?(arg); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:68 + def good_matcher(node, matcher); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:62 + def message(node, matcher); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:53 + def specific_matcher(arg); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:28 +RuboCop::Cop::RSpec::Capybara::SpecificMatcher::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:29 +RuboCop::Cop::RSpec::Capybara::SpecificMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/specific_matcher.rb:31 +RuboCop::Cop::RSpec::Capybara::SpecificMatcher::SPECIFIC_MATCHER = T.let(T.unsafe(nil), Hash) + +# Checks for boolean visibility in Capybara finders. +# +# Capybara lets you find elements that match a certain visibility using +# the `:visible` option. `:visible` accepts both boolean and symbols as +# values, however using booleans can have unwanted effects. `visible: +# false` does not find just invisible elements, but both visible and +# invisible elements. For expressiveness and clarity, use one of the +# symbol values, `:all`, `:hidden` or `:visible`. +# Read more in +# https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation]. +# +# @example +# +# # bad +# expect(page).to have_selector('.foo', visible: false) +# expect(page).to have_css('.foo', visible: true) +# expect(page).to have_link('my link', visible: false) +# +# # good +# expect(page).to have_selector('.foo', visible: :visible) +# expect(page).to have_css('.foo', visible: :all) +# expect(page).to have_link('my link', visible: :hidden) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:30 +class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:60 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:56 + def visible_false?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:51 + def visible_true?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:67 + def capybara_matcher?(method_name); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:33 +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::CAPYBARA_MATCHER_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:31 +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_FALSE = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:32 +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::MSG_TRUE = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb:48 +RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Prefer negated matchers over `to change.by(0)`. +# +# @example +# # bad +# expect { run }.to change(Foo, :bar).by(0) +# expect { run }.to change { Foo.bar }.by(0) +# +# # bad - compound expectations +# expect { run } +# .to change(Foo, :bar).by(0) +# .and change(Foo, :baz).by(0) +# expect { run } +# .to change { Foo.bar }.by(0) +# .and change { Foo.baz }.by(0) +# +# # good +# expect { run }.not_to change(Foo, :bar) +# expect { run }.not_to change { Foo.bar } +# +# # good - compound expectations +# define_negated_matcher :not_change, :change +# expect { run } +# .to not_change(Foo, :bar) +# .and not_change(Foo, :baz) +# expect { run } +# .to not_change { Foo.bar } +# .and not_change { Foo.baz } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:34 +class RuboCop::Cop::RSpec::ChangeByZero < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:42 + def expect_change_with_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:49 + def expect_change_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:58 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:85 + def autocorrect(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:70 + def check_offense(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:81 + def compound_expectations?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:36 +RuboCop::Cop::RSpec::ChangeByZero::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:37 +RuboCop::Cop::RSpec::ChangeByZero::MSG_COMPOUND = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/change_by_zero.rb:39 +RuboCop::Cop::RSpec::ChangeByZero::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Help methods for working with nodes containing comments. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:7 +module RuboCop::Cop::RSpec::CommentsHelp + include ::RuboCop::Cop::RSpec::FinalEndLocation + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:17 + def begin_pos_with_comment(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:32 + def buffer; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:27 + def end_line_position(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:10 + def source_range_with_comment(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/comments_help.rb:23 + def start_line_position(node); end +end + +# `context` should not be used for specifying methods. +# +# @example +# # bad +# context '#foo_bar' do +# # ... +# end +# +# context '.foo_bar' do +# # ... +# end +# +# # good +# describe '#foo_bar' do +# # ... +# end +# +# describe '.foo_bar' do +# # ... +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb:26 +class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb:32 + def context_method(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb:36 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb:46 + def method_name?(description); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_method.rb:29 +RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String) + +# Checks that `context` docstring starts with an allowed prefix. +# +# The default list of prefixes is minimal. Users are encouraged to tailor +# the configuration to meet project needs. Other acceptable prefixes may +# include `if`, `unless`, `for`, `before`, `after`, or `during`. +# They may consist of multiple words if desired. +# +# @example `Prefixes` configuration +# +# # .rubocop.yml +# # RSpec/ContextWording: +# # Prefixes: +# # - when +# # - with +# # - without +# # - if +# # - unless +# # - for +# @example +# # bad +# context 'the display name not present' do +# # ... +# end +# +# # good +# context 'when the display name is not present' do +# # ... +# end +# @see https://rspec.rubystyle.guide/#context-descriptions +# @see http://www.betterspecs.org/#contexts +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:38 +class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:42 + def context_wording(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:46 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:55 + def bad_prefix?(description); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:59 + def joined_prefixes; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:71 + def prefix_regex; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:67 + def prefixes; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/context_wording.rb:39 +RuboCop::Cop::RSpec::ContextWording::MSG = T.let(T.unsafe(nil), String) + +# Check that the first argument to the top-level describe is a constant. +# +# It can be configured to ignore strings when certain metadata is passed. +# +# Ignores Rails and Aruba `type` metadata by default. +# +# @example `IgnoredMetadata` configuration +# +# # .rubocop.yml +# # RSpec/DescribeClass: +# # IgnoredMetadata: +# # type: +# # - request +# # - controller +# @example +# # bad +# describe 'Do something' do +# end +# +# # good +# describe TestedClass do +# subject { described_class } +# end +# +# describe 'TestedClass::VERSION' do +# subject { Object.const_get(self.class.description) } +# end +# +# describe "A feature example", type: :feature do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:37 +class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:44 + def example_group_with_ignored_metadata?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:49 + def not_a_const_described(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:58 + def on_top_level_group(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:54 + def sym_pair(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:79 + def ignored_metadata; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:68 + def ignored_metadata?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:74 + def string_constant?(described); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_class.rb:40 +RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String) + +# Checks that the second argument to `describe` specifies a method. +# +# @example +# # bad +# describe MyClass, 'do something' do +# end +# +# # good +# describe MyClass, '#my_instance_method' do +# end +# +# describe MyClass, '.my_class_method' do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb:19 +class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb:32 + def on_top_level_group(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb:26 + def second_argument(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_method.rb:22 +RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String) + +# Avoid describing symbols. +# +# @example +# # bad +# describe :my_method do +# # ... +# end +# +# # good +# describe '#my_method' do +# # ... +# end +# @see https://github.com/rspec/rspec-core/issues/1610 +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb:20 +class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb:25 + def describe_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb:29 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb:21 +RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/describe_symbol.rb:22 +RuboCop::Cop::RSpec::DescribeSymbol::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that tests use `described_class`. +# +# If the first argument of describe is a class, the class is exposed to +# each example via described_class. +# +# This cop can be configured using the `EnforcedStyle` and `SkipBlocks` +# options. +# +# There's a known caveat with rspec-rails's `controller` helper that +# runs its block in a different context, and `described_class` is not +# available to it. `SkipBlocks` option excludes detection in all +# non-RSpec related blocks. +# +# To narrow down this setting to only a specific directory, it is +# possible to use an overriding configuration file local to that +# directory. +# +# @example `EnforcedStyle: described_class` (default) +# # bad +# describe MyClass do +# subject { MyClass.do_something } +# end +# +# # good +# describe MyClass do +# subject { described_class.do_something } +# end +# @example `EnforcedStyle: explicit` +# # bad +# describe MyClass do +# subject { described_class.do_something } +# end +# +# # good +# describe MyClass do +# subject { MyClass.do_something } +# end +# @example `SkipBlocks: true` +# # spec/controllers/.rubocop.yml +# # RSpec/DescribedClass: +# # SkipBlocks: true +# +# # acceptable +# describe MyConcern do +# controller(ApplicationController) do +# include MyConcern +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:57 +class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:65 + def common_instance_exec_closure?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:81 + def contains_described_class?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:76 + def described_constant(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:84 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:70 + def rspec_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:73 + def scope_changing_syntax?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:101 + def autocorrect(corrector, match); end + + # @example + # # nil represents base constant + # collapse_namespace([], [:C]) # => [:C] + # collapse_namespace([:A, :B], [:C]) # => [:A, :B, :C] + # collapse_namespace([:A, :B], [:B, :C]) # => [:A, :B, :C] + # collapse_namespace([:A, :B], [nil, :C]) # => [nil, :C] + # collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C] + # @param namespace [Array<Symbol>] + # @param const [Array<Symbol>] + # @return [Array<Symbol>] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:176 + def collapse_namespace(namespace, const); end + + # @example + # const_name(s(:const, nil, :C)) # => [:C] + # const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C] + # const_name(s(:const, s(:cbase), :C)) # => [nil, :C] + # @param node [RuboCop::AST::Node] + # @return [Array<Symbol>] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:193 + def const_name(node); end + + # @yield [node] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:111 + def find_usage(node, &block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:162 + def full_const_name(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:121 + def message(offense); end + + # @example + # namespace(node) # => [:A, :B, :C] + # @param node [RuboCop::AST::Node] + # @return [Array<Symbol>] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:208 + def namespace(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:140 + def offensive?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:148 + def offensive_described_class?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:130 + def scope_change?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:136 + def skippable_block?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:61 +RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class.rb:62 +RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String) + +# Avoid opening modules and defining specs within them. +# +# @example +# # bad +# module MyModule +# RSpec.describe MyClass do +# # ... +# end +# end +# +# # good +# RSpec.describe MyModule::MyClass do +# # ... +# end +# @see https://github.com/rubocop/rubocop-rspec/issues/735 +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb:22 +class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb:26 + def find_rspec_blocks(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb:28 + def on_module(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/described_class_module_wrapping.rb:23 +RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String) + +# Enforces custom RSpec dialects. +# +# A dialect can be based on the following RSpec methods: +# +# - describe, context, feature, example_group +# - xdescribe, xcontext, xfeature +# - fdescribe, fcontext, ffeature +# - shared_examples, shared_examples_for, shared_context +# - it, specify, example, scenario, its +# - fit, fspecify, fexample, fscenario, focus +# - xit, xspecify, xexample, xscenario, skip +# - pending +# - prepend_before, before, append_before, +# - around +# - prepend_after, after, append_after +# - let, let! +# - subject, subject! +# - expect, is_expected, expect_any_instance_of +# +# By default all of the RSpec methods and aliases are allowed. By setting +# a config like: +# +# RSpec/Dialect: +# PreferredMethods: +# context: describe +# +# You can expect the following behavior: +# +# @example +# # bad +# context 'display name presence' do +# # ... +# end +# +# # good +# describe 'display name presence' do +# # ... +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb:44 +class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb:53 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb:51 + def rspec_method?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/dialect.rb:48 +RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String) + +# Checks if an example group does not include any tests. +# +# @example usage +# +# # bad +# describe Bacon do +# let(:bacon) { Bacon.new(chunkiness) } +# let(:chunkiness) { false } +# +# context 'extra chunky' do # flagged by rubocop +# let(:chunkiness) { true } +# end +# +# it 'is chunky' do +# expect(bacon.chunky?).to be_truthy +# end +# end +# +# # good +# describe Bacon do +# let(:bacon) { Bacon.new(chunkiness) } +# let(:chunkiness) { false } +# +# it 'is chunky' do +# expect(bacon.chunky?).to be_truthy +# end +# end +# +# # good +# describe Bacon do +# pending 'will add tests later' +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:38 +class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Base + # Match example group blocks and yield their body + # + # @example source that matches + # describe 'example group' do + # it { is_expected.to be } + # end + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] example group body + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:51 + def example_group_body(param0 = T.unsafe(nil)); end + + # Match examples, example groups and includes + # + # @example source that matches + # it { is_expected.to fly } + # describe('non-empty example groups too') { } + # it_behaves_like 'an animal' + # it_behaves_like('a cat') { let(:food) { 'milk' } } + # it_has_root_access + # skip + # it 'will be implemented later' + # @param node [RuboCop::AST::Node] + # @return [Array<RuboCop::AST::Node>] matching nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:69 + def example_or_group_or_include?(param0 = T.unsafe(nil)); end + + # Matches examples defined in scopes where they could run + # + # @example source that matches + # it { expect(myself).to be_run } + # describe { it { i_run_as_well } } + # @example source that does not match + # before { it { whatever here wont run anyway } } + # @param node [RuboCop::AST::Node] + # @return [Array<RuboCop::AST::Node>] matching nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:126 + def examples?(param0 = T.unsafe(nil)); end + + # Match examples or examples inside blocks + # + # @example source that matches + # it { expect(drink).to be_cold } + # context('when winter') { it { expect(drink).to be_hot } } + # (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } } + # @param node [RuboCop::AST::Node] + # @return [Array<RuboCop::AST::Node>] matching nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:107 + def examples_directly_or_in_block?(param0 = T.unsafe(nil)); end + + # Match examples defined inside a block which is not a hook + # + # @example source that matches + # %w(r g b).each do |color| + # it { is_expected.to have_color(color) } + # end + # @example source that does not match + # before do + # it { is_expected.to fall_into_oblivion } + # end + # @param node [RuboCop::AST::Node] + # @return [Array<RuboCop::AST::Node>] matching nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:93 + def examples_inside_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:133 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:155 + def conditionals_with_examples?(body); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:163 + def examples_in_branches?(condition_node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:144 + def offensive?(body); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_example_group.rb:39 +RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty before and after hooks. +# +# @example +# # bad +# before {} +# after do; end +# before(:all) do +# end +# after(:all) { } +# +# # good +# before { create_users } +# after do +# cleanup_users +# end +# before(:all) do +# create_feed +# end +# after(:all) { cleanup_feed } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb:25 +class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb:32 + def empty_hook?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb:36 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_hook.rb:29 +RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after example blocks. +# +# @example +# # bad +# RSpec.describe Foo do +# it 'does this' do +# end +# it 'does that' do +# end +# end +# +# # good +# RSpec.describe Foo do +# it 'does this' do +# end +# +# it 'does that' do +# end +# end +# +# # fair - it's ok to have non-separated one-liners +# RSpec.describe Foo do +# it { one } +# it { two } +# end +# @example with AllowConsecutiveOneLiners configuration +# +# # rubocop.yml +# # RSpec/EmptyLineAfterExample: +# # AllowConsecutiveOneLiners: false +# +# # bad +# RSpec.describe Foo do +# it { one } +# it { two } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:44 +class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:63 + def allow_consecutive_one_liners?; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:59 + def allowed_one_liner?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:67 + def consecutive_one_liner?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:71 + def next_one_line_example?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:79 + def next_sibling(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:50 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example.rb:48 +RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after example group blocks. +# +# @example +# # bad +# RSpec.describe Foo do +# describe '#bar' do +# end +# describe '#baz' do +# end +# end +# +# # good +# RSpec.describe Foo do +# describe '#bar' do +# end +# +# describe '#baz' do +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb:26 +class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb:32 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_example_group.rb:30 +RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after the last let block. +# +# @example +# # bad +# let(:foo) { bar } +# let(:something) { other } +# it { does_something } +# +# # good +# let(:foo) { bar } +# let(:something) { other } +# +# it { does_something } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb:19 +class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb:25 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_final_let.rb:23 +RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after hook blocks. +# +# @example +# # bad +# before { do_something } +# it { does_something } +# +# # bad +# after { do_something } +# it { does_something } +# +# # bad +# around { |test| test.run } +# it { does_something } +# +# # good +# before { do_something } +# +# it { does_something } +# +# # good +# after { do_something } +# +# it { does_something } +# +# # good +# around { |test| test.run } +# +# it { does_something } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb:36 +class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb:42 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_hook.rb:40 +RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String) + +# Checks if there is an empty line after subject block. +# +# @example +# # bad +# subject(:obj) { described_class } +# let(:foo) { bar } +# +# # good +# subject(:obj) { described_class } +# +# let(:foo) { bar } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb:17 +class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::EmptyLineSeparation + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb:24 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/empty_line_after_subject.rb:22 +RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String) + +# Helps determine the offending location if there is not an empty line +# following the node. Allows comments to follow directly after +# in the following cases. +# - followed by empty line(s) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb:11 +module RuboCop::Cop::RSpec::EmptyLineSeparation + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RangeHelp + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb:52 + def last_child?(node); end + + # @yield [offending_loc(enable_directive_line || final_end_line)] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb:26 + def missing_separating_line(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb:15 + def missing_separating_line_offense(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb:42 + def offending_loc(last_line); end +end + +# Checks for long examples. +# +# A long example is usually more difficult to understand. Consider +# extracting out some behavior, e.g. with a `let` block, or a helper +# method. +# +# You can set literals you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', and 'heredoc'. Each literal +# will be counted as one line regardless of its actual size. +# +# @example +# # bad +# it do +# service = described_class.new +# more_setup +# more_setup +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it do +# service = described_class.new +# result = service.call +# expect(result).to be(true) +# end +# @example CountAsOne: ['array', 'heredoc'] +# +# it do +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# msg = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# end # 5 points +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb:50 +class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb:55 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb:63 + def cop_label; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_length.rb:53 +RuboCop::Cop::RSpec::ExampleLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks for examples without a description. +# +# RSpec allows for auto-generated example descriptions when there is no +# description provided or the description is an empty one. +# +# This cop removes empty descriptions. +# It also defines whether auto-generated description is allowed, based +# on the configured style. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: always_allow` (default) +# # bad +# it('') { is_expected.to be_good } +# it '' do +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it { is_expected.to be_good } +# it do +# result = service.call +# expect(result).to be(true) +# end +# @example `EnforcedStyle: single_line_only` +# # bad +# it('') { is_expected.to be_good } +# it do +# result = service.call +# expect(result).to be(true) +# end +# +# # good +# it { is_expected.to be_good } +# @example `EnforcedStyle: disallow` +# # bad +# it { is_expected.to be_good } +# it do +# result = service.call +# expect(result).to be(true) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:50 +class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:58 + def example_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:60 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:74 + def check_example_without_description(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:81 + def disallow_empty_description?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:55 +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_without_description.rb:53 +RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String) + +# Checks for common mistakes in example descriptions. +# +# This cop will correct docstrings that begin with 'should' and 'it'. +# +# The autocorrect is experimental - use with care! It can be configured +# with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only). +# +# @example +# # bad +# it 'should find nothing' do +# end +# +# # good +# it 'finds nothing' do +# end +# @example +# # bad +# it 'it does things' do +# end +# +# # good +# it 'does things' do +# end +# @see http://betterspecs.org/#should +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:32 +class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:42 + def it_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:49 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:61 + def add_wording_offense(node, message); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:108 + def custom_transform; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:71 + def docstring(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:112 + def ignored_words; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:81 + def replacement_text(node); end + + # Recursive processing is required to process nested dstr nodes + # that is the case for \-separated multiline strings with interpolation. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:97 + def text(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:39 +RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:36 +RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:35 +RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/example_wording.rb:38 +RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp) + +# Checks for excessive whitespace in example descriptions. +# +# @example +# # bad +# it ' has excessive spacing ' do +# end +# +# # good +# it 'has excessive spacing' do +# end +# @example +# # bad +# context ' when a condition is met ' do +# end +# +# # good +# context 'when a condition is met' do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:25 +class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:31 + def example_description(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:38 + def on_send(node); end + + private + + # @param node [RuboCop::AST::Node] + # @param text [String] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:66 + def add_whitespace_offense(node, text); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:75 + def docstring(node); end + + # @param text [String] + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:53 + def excessive_whitespace?(text); end + + # @param text [String] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:60 + def strip_excessive_whitespace(text); end + + # Recursive processing is required to process nested dstr nodes + # that is the case for \-separated multiline strings with interpolation. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:87 + def text(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb:28 +RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::MSG = T.let(T.unsafe(nil), String) + +# Checks for `expect(...)` calls containing literal values. +# +# Autocorrection is performed when the expected is not a literal. +# +# @example +# # bad +# expect(5).to eq(price) +# expect(/foo/).to eq(pattern) +# expect("John").to eq(name) +# +# # good +# expect(price).to eq(5) +# expect(pattern).to eq(/foo/) +# expect(name).to eq("John") +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:21 +class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:51 + def expect_literal(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:62 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:85 + def complex_literal?(node); end + + # This is not implement using a NodePattern because it seems + # to not be able to match against an explicit (nil) sexp + # + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:77 + def literal?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:81 + def simple_literal?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:90 + def swap(corrector, actual, expected); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:39 +RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:24 +RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:26 +RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_actual.rb:48 +RuboCop::Cop::RSpec::ExpectActual::SUPPORTED_MATCHERS = T.let(T.unsafe(nil), Array) + +# Checks for consistent style of change matcher. +# +# Enforces either passing object and attribute as arguments to the matcher +# or passing a block that reads the attribute value. +# +# This cop can be configured using the `EnforcedStyle` option. +# +# @example `EnforcedStyle: method_call` (default) +# # bad +# expect { run }.to change { Foo.bar } +# expect { run }.to change { foo.baz } +# +# # good +# expect { run }.to change(Foo, :bar) +# expect { run }.to change(foo, :baz) +# # also good when there are arguments or chained method calls +# expect { run }.to change { Foo.bar(:count) } +# expect { run }.to change { user.reload.name } +# @example `EnforcedStyle: block` +# # bad +# expect { run }.to change(Foo, :bar) +# +# # good +# expect { run }.to change { Foo.bar } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:32 +class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:41 + def expect_change_with_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:46 + def expect_change_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:72 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:60 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:36 +RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:37 +RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_change.rb:38 +RuboCop::Cop::RSpec::ExpectChange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Do not use `expect` in hooks such as `before`. +# +# @example +# # bad +# before do +# expect(something).to eq 'foo' +# end +# +# # bad +# after do +# expect_any_instance_of(Something).to receive(:foo) +# end +# +# # good +# it do +# expect(something).to eq 'foo' +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb:23 +class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb:27 + def expectation(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb:29 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb:41 + def message(expect, hook); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_in_hook.rb:24 +RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String) + +# Checks for opportunities to use `expect { ... }.to output`. +# +# @example +# # bad +# $stdout = StringIO.new +# my_app.print_report +# $stdout = STDOUT +# expect($stdout.string).to eq('Hello World') +# +# # good +# expect { my_app.print_report }.to output('Hello World').to_stdout +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb:17 +class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb:21 + def on_gvasgn(node); end + + private + + # Detect if we are inside the scope of a single example + # + # We want to encourage using `expect { ... }.to output` so + # we only care about situations where you would replace with + # an expectation. Therefore, assignments to stderr or stdout + # within a `before(:all)` or otherwise outside of an example + # don't matter. + # + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb:42 + def inside_example_scope?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/expect_output.rb:18 +RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String) + +# A helper for `explicit` style +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:121 +module RuboCop::Cop::RSpec::ExplicitHelper + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:159 + def predicate_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:168 + def predicate_matcher_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:135 + def allowed_explicit_matchers; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:139 + def check_explicit(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:191 + def corrector_explicit(corrector, to_node, actual, matcher, block_child); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:185 + def message_explicit(matcher); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:198 + def move_predicate(corrector, actual, matcher, block_child); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:177 + def predicate_matcher_name?(name); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:228 + def replacement_matcher(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:210 + def to_predicate_method(matcher); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:127 +RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:125 +RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:6 +module RuboCop::Cop::RSpec::FactoryBot; end + +# Always declare attribute values as blocks. +# +# @example +# # bad +# kind [:active, :rejected].sample +# +# # good +# kind { [:active, :rejected].sample } +# +# # bad +# closed_at 1.day.from_now +# +# # good +# closed_at { 1.day.from_now } +# +# # bad +# count 1 +# +# # good +# count { 1 } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:27 +class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:85 + def association?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:38 + def factory_attributes(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:42 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:33 + def value_matcher(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:119 + def attribute_defining_method?(method_name); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:58 + def autocorrect(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:87 + def autocorrect_replacing_parens(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:94 + def autocorrect_without_parens(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:103 + def braces(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:66 + def offensive_receiver?(receiver, node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:80 + def proc?(attribute); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:72 + def receiver_matches_first_block_argument?(receiver, node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:115 + def reserved_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:111 + def value_hash_without_braces?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb:30 +RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::MSG = T.let(T.unsafe(nil), String) + +# Checks for create_list usage. +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: create_list` (default) +# # bad +# 3.times { create :user } +# +# # good +# create_list :user, 3 +# +# # bad +# 3.times { create :user, age: 18 } +# +# # good - index is used to alter the created models attributes +# 3.times { |n| create :user, age: n } +# +# # good - contains a method call, may return different values +# 3.times { create :user, age: rand } +# @example `EnforcedStyle: n_times` +# # bad +# create_list :user, 3 +# +# # good +# 3.times { create :user } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:33 +class RuboCop::Cop::RSpec::FactoryBot::CreateList < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::RSpec::FactoryBot::Language + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:60 + def arguments_include_method_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:65 + def factory_call(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:70 + def factory_list_call(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:43 + def n_times_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:51 + def n_times_block_with_arg_and_used?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:74 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:88 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:101 + def contains_only_factory?(node); end +end + +# :nodoc +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:110 +module RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:113 + def build_options_string(options); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:117 + def format_method_call(node, method, arguments); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:125 + def format_receiver(receiver); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:163 +class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector + include ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + + # @return [CreateListCorrector] a new instance of CreateListCorrector + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:166 + def initialize(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:170 + def call(corrector); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:193 + def build_arguments(node, count); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:202 + def call_replacement(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:184 + def call_with_block_replacement(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:215 + def format_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:223 + def format_multiline_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:231 + def format_singleline_block(node); end + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:182 + def node; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:38 +RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_CREATE_LIST = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:39 +RuboCop::Cop::RSpec::FactoryBot::CreateList::MSG_N_TIMES = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:40 +RuboCop::Cop::RSpec::FactoryBot::CreateList::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# :nodoc +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:133 +class RuboCop::Cop::RSpec::FactoryBot::CreateList::TimesCorrector + include ::RuboCop::Cop::RSpec::FactoryBot::CreateList::Corrector + + # @return [TimesCorrector] a new instance of TimesCorrector + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:136 + def initialize(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:140 + def call(corrector); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:149 + def generate_n_times_block(node); end + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/create_list.rb:147 + def node; end +end + +# Use string value when setting the class attribute explicitly. +# +# This cop would promote faster tests by lazy-loading of +# application files. Also, this could help you suppress potential bugs +# in combination with external libraries by avoiding a preload of +# application files from the factory files. +# +# @example +# # bad +# factory :foo, class: Foo do +# end +# +# # good +# factory :foo, class: 'Foo' do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:22 +class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:31 + def class_name(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:48 + def allowed?(const_name); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:27 +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::ALLOWED_CONSTANTS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:25 +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb:28 +RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Use shorthands from `FactoryBot::Syntax::Methods` in your specs. +# +# @example +# # bad +# FactoryBot.create(:bar) +# FactoryBot.build(:bar) +# FactoryBot.attributes_for(:bar) +# +# # good +# create(:bar) +# build(:bar) +# attributes_for(:bar) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:49 +class RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::InsideExampleGroup + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::RSpec::FactoryBot::Language + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:77 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:90 + def crime_scene(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:97 + def offense(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:55 +RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb:57 +RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks that spec file paths are consistent and well-formed. +# +# By default, this checks that spec file paths are consistent with the +# test subject and and enforces that it reflects the described +# class/module and its optionally called out method. +# +# With the configuration option `IgnoreMethods` the called out method will +# be ignored when determining the enforced path. +# +# With the configuration option `CustomTransform` modules or classes can +# be specified that should not as usual be transformed from CamelCase to +# snake_case (e.g. 'RuboCop' => 'rubocop' ). +# +# With the configuration option `SpecSuffixOnly` test files will only +# be checked to ensure they end in '_spec.rb'. This option disables +# checking for consistency in the test subject or test methods. +# +# @example +# # bad +# whatever_spec.rb # describe MyClass +# +# # bad +# my_class_spec.rb # describe MyClass, '#method' +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_method_spec.rb # describe MyClass, '#method' +# +# # good +# my_class/method_spec.rb # describe MyClass, '#method' +# @example when configuration is `IgnoreMethods: true` +# # bad +# whatever_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass, '#method' +# @example when configuration is `SpecSuffixOnly: true` +# # good +# whatever_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass +# +# # good +# my_class_spec.rb # describe MyClass, '#method' +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:59 +class RuboCop::Cop::RSpec::FilePath < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:65 + def example_group(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:74 + def on_top_level_example_group(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:72 + def routing_metadata?(param0); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:133 + def camel_to_snake_case(string); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:140 + def custom_transform; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:86 + def ensure_correct_file_path(send_node, example_group, arguments); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:125 + def expected_path(constant); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:148 + def filename_ends_with?(pattern); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:144 + def ignore_methods?; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:118 + def name_pattern(method_name); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:102 + def pattern_for(example_group, method_name); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:114 + def pattern_for_spec_suffix_only?; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:153 + def relevant_rubocop_rspec_file?(_file); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:98 + def routing_spec?(args); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:157 + def spec_suffix_only?; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/file_path.rb:62 +RuboCop::Cop::RSpec::FilePath::MSG = T.let(T.unsafe(nil), String) + +# Helps find the true end location of nodes which might contain heredocs. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/final_end_location.rb:7 +module RuboCop::Cop::RSpec::FinalEndLocation + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/final_end_location.rb:8 + def final_end_location(start_node); end +end + +# Checks if examples are focused. +# +# @example +# # bad +# describe MyClass, focus: true do +# end +# +# describe MyClass, :focus do +# end +# +# fdescribe MyClass do +# end +# +# # good +# describe MyClass do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:22 +class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:29 + def focusable_selector?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:46 + def focused_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:40 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:51 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:78 + def correct_send(corrector, focus); end + + # @yield [node] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:65 + def focus_metadata(node, &block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:71 + def with_surrounding(focus); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/focus.rb:26 +RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String) + +# Checks the arguments passed to `before`, `around`, and `after`. +# +# This cop checks for consistent style when specifying RSpec +# hooks which run for each example. There are three supported +# styles: "implicit", "each", and "example." All styles have +# the same behavior. +# +# @example `EnforcedStyle: implicit` (default) +# # bad +# before(:each) do +# # ... +# end +# +# # bad +# before(:example) do +# # ... +# end +# +# # good +# before do +# # ... +# end +# @example `EnforcedStyle: each` +# # bad +# before(:example) do +# # ... +# end +# +# # bad +# before do +# # ... +# end +# +# # good +# before(:each) do +# # ... +# end +# @example `EnforcedStyle: example` +# # bad +# before(:each) do +# # ... +# end +# +# # bad +# before do +# # ... +# end +# +# # good +# before(:example) do +# # ... +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:60 +class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:75 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:68 + def scoped_hook(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:73 + def unscoped_hook(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:118 + def argument_range(send_node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:91 + def check_implicit(method_send); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:102 + def explicit_message(scope); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:114 + def hook(node, &block); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:110 + def implicit_style?; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:65 +RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hook_argument.rb:64 +RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String) + +# Checks for before/around/after hooks that come after an example. +# +# @example +# # Bad +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# before { prepare } +# after { clean_up } +# +# # Good +# before { prepare } +# after { clean_up } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:26 +class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:32 + def example_or_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:39 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:70 + def autocorrect(corrector, node, first_example); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:51 + def check_hooks(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:66 + def find_first_example(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:47 + def multiline_block?(block); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/hooks_before_examples.rb:29 +RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +# Checks for equality assertions with identical expressions on both sides. +# +# @example +# +# # bad +# expect(foo.bar).to eq(foo.bar) +# expect(foo.bar).to eql(foo.bar) +# +# # good +# expect(foo.bar).to eq(2) +# expect(foo.bar).to eql(2) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb:18 +class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb:24 + def equality_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb:30 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb:19 +RuboCop::Cop::RSpec::IdenticalEqualityAssertion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/identical_equality_assertion.rb:21 +RuboCop::Cop::RSpec::IdenticalEqualityAssertion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that implicit block expectation syntax is not used. +# +# Prefer using explicit block expectations. +# +# @example +# # bad +# subject { -> { do_something } } +# it { is_expected.to change(something).to(new_value) } +# +# # good +# it 'changes something to a new value' do +# expect { do_something }.to change(something).to(new_value) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:19 +class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:35 + def implicit_expect(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:24 + def lambda?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:32 + def lambda_subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:39 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:61 + def find_subject(block_node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:57 + def multi_statement_example_group?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:48 + def nearest_subject(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:20 +RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_block_expectation.rb:21 +RuboCop::Cop::RSpec::ImplicitBlockExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that a consistent implicit expectation style is used. +# +# This cop can be configured using the `EnforcedStyle` option +# and supports the `--auto-gen-config` flag. +# +# @example `EnforcedStyle: is_expected` (default) +# +# # bad +# it { should be_truthy } +# +# # good +# it { is_expected.to be_truthy } +# @example `EnforcedStyle: should` +# +# # bad +# it { is_expected.to be_truthy } +# +# # good +# it { should be_truthy } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:27 +class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:34 + def implicit_expect(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:49 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:78 + def is_expected_range(source_map); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:69 + def offending_expect(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:86 + def offense_message(offending_source); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:94 + def replacement_source(offending_source); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:47 +RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_expect.rb:31 +RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of implicit subject (`is_expected` / `should`). +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: single_line_only` (default) +# # bad +# it do +# is_expected.to be_truthy +# end +# +# # good +# it { is_expected.to be_truthy } +# it do +# expect(subject).to be_truthy +# end +# @example `EnforcedStyle: single_statement_only` +# # bad +# it do +# foo = 1 +# is_expected.to be_truthy +# end +# +# # good +# it do +# foo = 1 +# expect(subject).to be_truthy +# end +# it do +# is_expected.to be_truthy +# end +# @example `EnforcedStyle: disallow` +# # bad +# it { is_expected.to be_truthy } +# +# # good +# it { expect(subject).to be_truthy } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:45 +class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:53 + def implicit_subject?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:57 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:87 + def allowed_by_style?(example); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:68 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:80 + def valid_usage?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:49 +RuboCop::Cop::RSpec::ImplicitSubject::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/implicit_subject.rb:50 +RuboCop::Cop::RSpec::ImplicitSubject::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# A helper for `inflected` style +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:7 +module RuboCop::Cop::RSpec::InflectedHelper + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:39 + def be_bool?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:44 + def be_boolthy?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:29 + def predicate_in_actual?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:48 + def boolean_matcher?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:16 + def check_inflected(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:60 + def message_inflected(predicate); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:56 + def predicate?(sym); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:85 + def remove_predicate(corrector, predicate); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:96 + def rewrite_matcher(corrector, predicate, matcher); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:67 + def to_predicate_matcher(name); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:107 + def true?(to_symbol, matcher); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:11 +RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String) + +# Helps you identify whether a given node +# is within an example group or not. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb:8 +module RuboCop::Cop::RSpec::InsideExampleGroup + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb:19 + def example_group_root?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb:23 + def example_group_root_with_siblings?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/inside_example_group.rb:11 + def inside_example_group?(node); end +end + +# Checks for `instance_double` used with `have_received`. +# +# @example +# # bad +# it do +# foo = instance_double(Foo).as_null_object +# expect(foo).to have_received(:bar) +# end +# +# # good +# it do +# foo = instance_spy(Foo) +# expect(foo).to have_received(:bar) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:21 +class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:36 + def have_received_usage(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:28 + def null_double(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:45 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:61 + def autocorrect(corrector, node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_spy.rb:24 +RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String) + +# Checks for instance variable usage in specs. +# +# This cop can be configured with the option `AssignmentOnly` which +# will configure the cop to only register offenses on instance +# variable usage if the instance variable is also assigned within +# the spec +# +# @example +# # bad +# describe MyClass do +# before { @foo = [] } +# it { expect(@foo).to be_empty } +# end +# +# # good +# describe MyClass do +# let(:foo) { [] } +# it { expect(foo).to be_empty } +# end +# @example with AssignmentOnly configuration +# +# # rubocop.yml +# # RSpec/InstanceVariable: +# # AssignmentOnly: false +# +# # bad +# describe MyClass do +# before { @foo = [] } +# it { expect(@foo).to be_empty } +# end +# +# # allowed +# describe MyClass do +# it { expect(@foo).to be_empty } +# end +# +# # good +# describe MyClass do +# let(:foo) { [] } +# it { expect(foo).to be_empty } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:49 +class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:61 + def custom_matcher?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:56 + def dynamic_class?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:72 + def ivar_assigned?(param0, param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:69 + def ivar_usage(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:74 + def on_top_level_group(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:91 + def assignment_only?; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:85 + def valid_usage?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/instance_variable.rb:52 +RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String) + +# Checks that only one `it_behaves_like` style is used. +# +# @example `EnforcedStyle: it_behaves_like` (default) +# # bad +# it_should_behave_like 'a foo' +# +# # good +# it_behaves_like 'a foo' +# @example `EnforcedStyle: it_should_behave_like` +# # bad +# it_behaves_like 'a foo' +# +# # good +# it_should_behave_like 'a foo' +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:21 +class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:30 + def example_inclusion_offense(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:32 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:42 + def message(_node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:25 +RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/it_behaves_like.rb:27 +RuboCop::Cop::RSpec::ItBehavesLike::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check that `all` matcher is used instead of iterating over an array. +# +# @example +# # bad +# it 'validates users' do +# [user1, user2, user3].each { |user| expect(user).to be_valid } +# end +# +# # good +# it 'validates users' do +# expect([user1, user2, user3]).to all(be_valid) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:18 +class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:23 + def each?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:32 + def expectation?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:36 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:50 + def only_expectations?(body, arg); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:46 + def single_expectation?(body, arg); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/iterated_expectation.rb:19 +RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String) + +# Enforce that subject is the first definition in the test. +# +# @example +# # bad +# let(:params) { blah } +# subject { described_class.new(params) } +# +# before { do_something } +# subject { described_class.new(params) } +# +# it { expect_something } +# subject { described_class.new(params) } +# it { expect_something_else } +# +# # good +# subject { described_class.new(params) } +# let(:params) { blah } +# +# # good +# subject { described_class.new(params) } +# before { do_something } +# +# # good +# subject { described_class.new(params) } +# it { expect_something } +# it { expect_something_else } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:34 +class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::InsideExampleGroup + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:47 + def check_previous_nodes(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:40 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:70 + def autocorrect(corrector, node, sibling); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:76 + def offending?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:58 + def offending_node(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:66 + def parent(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leading_subject.rb:38 +RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String) + +# Checks that no class, module, or constant is declared. +# +# Constants, including classes and modules, when declared in a block +# scope, are defined in global namespace, and leak between examples. +# +# If several examples may define a `DummyClass`, instead of being a +# blank slate class as it will be in the first example, subsequent +# examples will be reopening it and modifying its behavior in +# unpredictable ways. +# Even worse when a class that exists in the codebase is reopened. +# +# Anonymous classes are fine, since they don't result in global +# namespace name clashes. +# +# @example Constants leak between examples +# # bad +# describe SomeClass do +# OtherClass = Struct.new +# CONSTANT_HERE = 'I leak into global namespace' +# end +# +# # good +# describe SomeClass do +# before do +# stub_const('OtherClass', Struct.new) +# stub_const('CONSTANT_HERE', 'I only exist during this example') +# end +# end +# @example +# # bad +# describe SomeClass do +# class FooClass < described_class +# def double_that +# some_base_method * 2 +# end +# end +# +# it { expect(FooClass.new.double_that).to eq(4) } +# end +# +# # good - anonymous class, no constant needs to be defined +# describe SomeClass do +# let(:foo_class) do +# Class.new(described_class) do +# def double_that +# some_base_method * 2 +# end +# end +# end +# +# it { expect(foo_class.new.double_that).to eq(4) } +# end +# +# # good - constant is stubbed +# describe SomeClass do +# before do +# foo_class = Class.new(described_class) do +# def do_something +# end +# end +# stub_const('FooClass', foo_class) +# end +# +# it { expect(FooClass.new.double_that).to eq(4) } +# end +# @example +# # bad +# describe SomeClass do +# module SomeModule +# class SomeClass +# def do_something +# end +# end +# end +# end +# +# # good +# describe SomeClass do +# before do +# foo_class = Class.new(described_class) do +# def do_something +# end +# end +# stub_const('SomeModule::SomeClass', foo_class) +# end +# end +# @see https://relishapp.com/rspec/rspec-mocks/docs/mutating-constants +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:96 +class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:101 + def on_casgn(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:107 + def on_class(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:113 + def on_module(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:121 + def inside_describe_block?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:98 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:97 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/leaky_constant_declaration.rb:99 +RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String) + +# Checks for `let` definitions that come after an example. +# +# @example +# # Bad +# let(:foo) { bar } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# let(:some) { other } +# +# it 'checks what some does' do +# expect(some).to be +# end +# +# # Good +# let(:foo) { bar } +# let(:some) { other } +# +# it 'checks what foo does' do +# expect(foo).to be +# end +# +# it 'checks what some does' do +# expect(some).to be +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:33 +class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:39 + def example_or_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:46 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:76 + def autocorrect(corrector, node, first_example); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:58 + def check_let_declarations(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:72 + def find_first_example(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:54 + def multiline_block?(block); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_before_examples.rb:36 +RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String) + +# Checks unreferenced `let!` calls being used for test setup. +# +# @example +# # Bad +# let!(:my_widget) { create(:widget) } +# +# it 'counts widgets' do +# expect(Widget.count).to eq(1) +# end +# +# # Good +# it 'counts widgets' do +# create(:widget) +# expect(Widget.count).to eq(1) +# end +# +# # Good +# before { create(:widget) } +# +# it 'counts widgets' do +# expect(Widget.count).to eq(1) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:28 +class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:32 + def example_or_shared_group_or_including?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:42 + def let_bang(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:50 + def method_called?(param0, param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:52 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:68 + def child_let_bang(node, &block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:62 + def unused_let_bang(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/let_setup.rb:29 +RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String) + +# Check that chains of messages are not being stubbed. +# +# @example +# # bad +# allow(foo).to receive_message_chain(:bar, :baz).and_return(42) +# +# # better +# thing = Thing.new(baz: 42) +# allow(foo).to receive(:bar).and_return(thing) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb:16 +class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb:20 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb:17 +RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_chain.rb:18 +RuboCop::Cop::RSpec::MessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for consistent message expectation style. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: allow` (default) +# +# # bad +# expect(foo).to receive(:bar) +# +# # good +# allow(foo).to receive(:bar) +# @example `EnforcedStyle: expect` +# +# # bad +# allow(foo).to receive(:bar) +# +# # good +# expect(foo).to receive(:bar) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:27 +class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:36 + def message_expectation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:43 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:41 + def receive_message?(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:56 + def preferred_style?(expectation); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:30 +RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:33 +RuboCop::Cop::RSpec::MessageExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_expectation.rb:32 +RuboCop::Cop::RSpec::MessageExpectation::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array) + +# Checks that message expectations are set using spies. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: have_received` (default) +# +# # bad +# expect(foo).to receive(:bar) +# do_something +# +# # good +# allow(foo).to receive(:bar) # or use instance_spy +# do_something +# expect(foo).to have_received(:bar) +# @example `EnforcedStyle: receive` +# +# # bad +# allow(foo).to receive(:bar) +# do_something +# expect(foo).to have_received(:bar) +# +# # good +# expect(foo).to receive(:bar) +# do_something +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:33 +class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:45 + def message_expectation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:54 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:50 + def receive_message(param0); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:77 + def error_message(receiver); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:73 + def preferred_style?(expectation); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:67 + def receive_message_matcher(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:38 +RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:36 +RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/message_spies.rb:42 +RuboCop::Cop::RSpec::MessageSpies::SUPPORTED_STYLES = T.let(T.unsafe(nil), Array) + +# Checks that the first argument to an example group is not empty. +# +# @example +# # bad +# describe do +# end +# +# RSpec.describe do +# end +# +# # good +# describe TestedClass do +# end +# +# describe "A feature example" do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb:22 +class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb:25 + def on_block(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/missing_example_group_argument.rb:23 +RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for multiple top-level example groups. +# +# Multiple descriptions for the same class or module should either +# be nested or separated into different test files. +# +# @example +# # bad +# describe MyClass, '.do_something' do +# end +# describe MyClass, '.do_something_else' do +# end +# +# # good +# describe MyClass do +# describe '.do_something' do +# end +# describe '.do_something_else' do +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb:25 +class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb:30 + def on_top_level_group(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_describes.rb:28 +RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String) + +# Checks if examples contain too many `expect` calls. +# +# This cop is configurable using the `Max` option +# and works with `--auto-gen-config`. +# +# @example +# +# # bad +# describe UserCreator do +# it 'builds a user' do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# +# # good +# describe UserCreator do +# it 'sets the users name' do +# expect(user.name).to eq("John") +# end +# +# it 'sets the users age' do +# expect(user.age).to eq(22) +# end +# end +# @example `aggregate_failures: true` (default) +# +# # good - the cop ignores when RSpec aggregates failures +# describe UserCreator do +# it 'builds a user', :aggregate_failures do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @example `aggregate_failures: false` +# +# # Detected as an offense +# describe UserCreator do +# it 'builds a user', aggregate_failures: false do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @example configuration +# +# # .rubocop.yml +# # RSpec/MultipleExpectations: +# # Max: 2 +# +# # not flagged by rubocop +# describe UserCreator do +# it 'builds a user' do +# expect(user.name).to eq("John") +# expect(user.age).to eq(22) +# end +# end +# @see http://betterspecs.org/#single Single expectation test +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:68 +class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:77 + def aggregate_failures?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:87 + def aggregate_failures_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:85 + def expect?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:91 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:107 + def example_with_aggregate_failures?(example_node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:114 + def find_aggregate_failures(example_node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:119 + def find_expectation(node, &block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:130 + def flag_example(node, expectation_count:); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:141 + def max_expectations; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:73 +RuboCop::Cop::RSpec::MultipleExpectations::ANYTHING = T.let(T.unsafe(nil), Proc) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:71 +RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_expectations.rb:74 +RuboCop::Cop::RSpec::MultipleExpectations::TRUE = T.let(T.unsafe(nil), Proc) + +# Checks if example groups contain too many `let` and `subject` calls. +# +# This cop is configurable using the `Max` option and the `AllowSubject` +# which will configure the cop to only register offenses on calls to +# `let` and not calls to `subject`. +# +# @example +# # bad +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# +# context 'when stuff' do +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# end +# +# # good +# describe MyClass do +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# +# describe MyClass do +# context 'when stuff' do +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:booger) { [] } +# end +# +# context 'when other stuff' do +# let(:qux) { [] } +# let(:quux) { [] } +# let(:quuz) { {} } +# end +# end +# @example when disabling AllowSubject configuration +# +# # rubocop.yml +# # RSpec/MultipleMemoizedHelpers: +# # AllowSubject: false +# +# # bad - `subject` counts towards memoized helpers +# describe MyClass do +# subject { {} } +# let(:foo) { [] } +# let(:bar) { [] } +# let!(:baz) { [] } +# let(:qux) { [] } +# let(:quux) { [] } +# end +# @example with Max configuration +# +# # rubocop.yml +# # RSpec/MultipleMemoizedHelpers: +# # Max: 1 +# +# # bad +# describe MyClass do +# let(:foo) { [] } +# let(:bar) { [] } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:86 +class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::RSpec::Variable + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:92 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:103 + def on_new_investigation; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:112 + def all_helpers(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:144 + def allow_subject?; end + + # Returns the value of attribute example_group_memoized_helpers. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:110 + def example_group_memoized_helpers; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:119 + def helpers(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:140 + def max; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:130 + def variable_nodes(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb:90 +RuboCop::Cop::RSpec::MultipleMemoizedHelpers::MSG = T.let(T.unsafe(nil), String) + +# Checks if an example group defines `subject` multiple times. +# +# The autocorrect behavior for this cop depends on the type of +# duplication: +# +# - If multiple named subjects are defined then this probably indicates +# that the overwritten subjects (all subjects except the last +# definition) are effectively being used to define helpers. In this +# case they are replaced with `let`. +# +# - If multiple unnamed subjects are defined though then this can *only* +# be dead code and we remove the overwritten subject definitions. +# +# - If subjects are defined with `subject!` then we don't autocorrect. +# This is enough of an edge case that people can just move this to +# a `before` hook on their own +# +# @example +# +# # bad +# describe Foo do +# subject(:user) { User.new } +# subject(:post) { Post.new } +# end +# +# # good +# describe Foo do +# let(:user) { User.new } +# subject(:post) { Post.new } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:36 +class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:42 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:56 + def autocorrect(corrector, subject); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:66 + def named_subject?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:74 + def remove_autocorrect(corrector, node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:70 + def rename_autocorrect(corrector, node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/multiple_subjects.rb:40 +RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String) + +# Checks for explicitly referenced test subjects. +# +# RSpec lets you declare an "implicit subject" using `subject { ... }` +# which allows for tests like `it { is_expected.to be_valid }`. +# If you need to reference your test subject you should explicitly +# name it using `subject(:your_subject_name) { ... }`. Your test subjects +# should be the most important object in your tests so they deserve +# a descriptive name. +# +# This cop can be configured in your configuration using the +# `IgnoreSharedExamples` which will not report offenses for implicit +# subjects in shared example groups. +# +# @example +# # bad +# RSpec.describe User do +# subject { described_class.new } +# +# it 'is valid' do +# expect(subject.valid?).to be(true) +# end +# end +# +# # good +# RSpec.describe Foo do +# subject(:user) { described_class.new } +# +# it 'is valid' do +# expect(user.valid?).to be(true) +# end +# end +# +# # also good +# RSpec.describe Foo do +# subject(:user) { described_class.new } +# +# it { is_expected.to be_valid } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:44 +class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:48 + def example_or_hook_block?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:68 + def ignored_shared_example?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:58 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:52 + def shared_example?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:56 + def subject_usage(param0); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/named_subject.rb:45 +RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String) + +# Checks for nested example groups. +# +# This cop is configurable using the `Max` option +# and supports `--auto-gen-config`. +# +# @example +# # bad +# context 'when using some feature' do +# let(:some) { :various } +# let(:feature) { :setup } +# +# context 'when user is signed in' do # flagged by rubocop +# let(:user) do +# UserCreate.call(user_attributes) +# end +# +# let(:user_attributes) do +# { +# name: 'John', +# age: 22, +# role: role +# } +# end +# +# context 'when user is an admin' do # flagged by rubocop +# let(:role) { 'admin' } +# +# it 'blah blah' +# it 'yada yada' +# end +# end +# end +# +# # better +# context 'using some feature as an admin' do +# let(:some) { :various } +# let(:feature) { :setup } +# +# let(:user) do +# UserCreate.call( +# name: 'John', +# age: 22, +# role: 'admin' +# ) +# end +# +# it 'blah blah' +# it 'yada yada' +# end +# @example configuration +# +# # .rubocop.yml +# # RSpec/NestedGroups: +# # Max: 2 +# +# context 'when using some feature' do +# let(:some) { :various } +# let(:feature) { :setup } +# +# context 'when user is signed in' do +# let(:user) do +# UserCreate.call(user_attributes) +# end +# +# let(:user_attributes) do +# { +# name: 'John', +# age: 22, +# role: role +# } +# end +# +# context 'when user is an admin' do # flagged by rubocop +# let(:role) { 'admin' } +# +# it 'blah blah' +# it 'yada yada' +# end +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:88 +class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:100 + def on_top_level_group(node); end + + private + + # @yield [node, nesting] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:112 + def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:127 + def max_nesting; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:131 + def max_nesting_config; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:123 + def message(nesting); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:94 +RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:96 +RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/nested_groups.rb:92 +RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent method usage for negating expectations. +# +# @example `EnforcedStyle: not_to` (default) +# +# # bad +# it '...' do +# expect(false).to_not be_true +# end +# +# # good +# it '...' do +# expect(false).not_to be_true +# end +# @example `EnforcedStyle: to_not` +# +# # bad +# it '...' do +# expect(false).not_to be_true +# end +# +# # good +# it '...' do +# expect(false).to_not be_true +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:31 +class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:39 + def not_to_not_offense(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:41 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:51 + def message(_node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:35 +RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/not_to_not.rb:36 +RuboCop::Cop::RSpec::NotToNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks if there is a let/subject that overwrites an existing one. +# +# @example +# # bad +# let(:foo) { bar } +# let(:foo) { baz } +# +# subject(:foo) { bar } +# let(:foo) { baz } +# +# let(:foo) { bar } +# let!(:foo) { baz } +# +# # good +# subject(:test) { something } +# let(:foo) { bar } +# let(:baz) { baz } +# let!(:other) { other } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:24 +class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:31 + def first_argument_name(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:33 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:28 + def setup?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:61 + def common_setup?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:46 + def find_duplicates(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/overwriting_setup.rb:25 +RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String) + +# Checks for any pending or skipped examples. +# +# @example +# # bad +# describe MyClass do +# it "should be true" +# end +# +# describe MyClass do +# it "should be true", skip: true do +# expect(1).to eq(2) +# end +# end +# +# describe MyClass do +# it "should be true" do +# pending +# end +# end +# +# describe MyClass do +# xit "should be true" do +# end +# end +# +# # good +# describe MyClass do +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:34 +class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:64 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:55 + def pending_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:52 + def skip_or_pending?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:38 + def skippable?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:44 + def skipped_in_metadata?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:72 + def skipped?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/pending.rb:35 +RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String) + +# Prefer using predicate matcher over using predicate method directly. +# +# RSpec defines magic matchers for predicate methods. +# This cop recommends to use the predicate matcher instead of using +# predicate method directly. +# +# @example Strict: true, EnforcedStyle: inflected (default) +# # bad +# expect(foo.something?).to be_truthy +# +# # good +# expect(foo).to be_something +# +# # also good - It checks "true" strictly. +# expect(foo.something?).to be(true) +# @example Strict: false, EnforcedStyle: inflected +# # bad +# expect(foo.something?).to be_truthy +# expect(foo.something?).to be(true) +# +# # good +# expect(foo).to be_something +# @example Strict: true, EnforcedStyle: explicit +# # bad +# expect(foo).to be_something +# +# # good - the above code is rewritten to it by this cop +# expect(foo.something?).to be(true) +# @example Strict: false, EnforcedStyle: explicit +# # bad +# expect(foo).to be_something +# +# # good - the above code is rewritten to it by this cop +# expect(foo.something?).to be_truthy +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:279 +class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::InflectedHelper + include ::RuboCop::Cop::RSpec::ExplicitHelper + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:294 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:285 + def on_send(node); end + + private + + # returns args location with whitespace + # + # @example + # foo 1, 2 + # ^^^^^ + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:304 + def args_loc(send_node); end + + # returns block location with whitespace + # + # @example + # foo { bar } + # ^^^^^^^^ + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/predicate_matcher.rb:314 + def block_loc(send_node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb:6 +module RuboCop::Cop::RSpec::Rails; end + +# Checks that tests use RSpec `before` hook over Rails `setup` method. +# +# @example +# +# # bad +# setup do +# allow(foo).to receive(:bar) +# end +# +# # good +# before do +# allow(foo).to receive(:bar) +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb:21 +class RuboCop::Cop::RSpec::Rails::AvoidSetupHook < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb:33 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb:27 + def setup_call(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/avoid_setup_hook.rb:24 +RuboCop::Cop::RSpec::Rails::AvoidSetupHook::MSG = T.let(T.unsafe(nil), String) + +# Checks that tests use `have_http_status` instead of equality matchers. +# +# @example +# # bad +# expect(response.status).to be(200) +# +# # good +# expect(response).to have_http_status(200) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb:16 +class RuboCop::Cop::RSpec::Rails::HaveHttpStatus < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb:24 + def match_status(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb:34 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/rails/have_http_status.rb:19 +RuboCop::Cop::RSpec::Rails::HaveHttpStatus::MSG = T.let(T.unsafe(nil), String) + +# Check for `once` and `twice` receive counts matchers usage. +# +# @example +# +# # bad +# expect(foo).to receive(:bar).exactly(1).times +# expect(foo).to receive(:bar).exactly(2).times +# expect(foo).to receive(:bar).at_least(1).times +# expect(foo).to receive(:bar).at_least(2).times +# expect(foo).to receive(:bar).at_most(1).times +# expect(foo).to receive(:bar).at_most(2).times +# +# # good +# expect(foo).to receive(:bar).once +# expect(foo).to receive(:bar).twice +# expect(foo).to receive(:bar).at_least(:once) +# expect(foo).to receive(:bar).at_least(:twice) +# expect(foo).to receive(:bar).at_most(:once) +# expect(foo).to receive(:bar).at_most(:twice).times +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:26 +class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:41 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:34 + def receive_counts(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:39 + def stub?(param0); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:56 + def autocorrect(corrector, node, range); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:73 + def matcher_for(method, count); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:65 + def message_for(node, source); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:82 + def range(node, offending_node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:29 +RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_counts.rb:31 +RuboCop::Cop::RSpec::ReceiveCounts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Prefer `not_to receive(...)` over `receive(...).never`. +# +# @example +# +# # bad +# expect(foo).to receive(:bar).never +# +# # good +# expect(foo).not_to receive(:bar) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:16 +class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:22 + def method_on_stub?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:24 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:34 + def autocorrect(corrector, node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:18 +RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/receive_never.rb:19 +RuboCop::Cop::RSpec::ReceiveNever::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for repeated description strings in example groups. +# +# @example +# +# # bad +# RSpec.describe User do +# it 'is valid' do +# # ... +# end +# +# it 'is valid' do +# # ... +# end +# end +# +# # good +# RSpec.describe User do +# it 'is valid when first and last name are present' do +# # ... +# end +# +# it 'is valid when last name only is present' do +# # ... +# end +# end +# +# # good +# RSpec.describe User do +# it 'is valid' do +# # ... +# end +# +# it 'is valid', :flag do +# # ... +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb:43 +class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb:46 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb:70 + def example_signature(example); end + + # Select examples in the current scope with repeated description strings + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb:57 + def repeated_descriptions(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_description.rb:44 +RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated examples within example groups. +# +# @example +# +# it 'is valid' do +# expect(user).to be_valid +# end +# +# it 'validates the user' do +# expect(user).to be_valid +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb:18 +class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb:21 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb:41 + def example_signature(example); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb:31 + def repeated_examples(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example.rb:19 +RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated describe and context block body. +# +# @example +# +# # bad +# describe 'cool feature x' do +# it { cool_predicate } +# end +# +# describe 'cool feature y' do +# it { cool_predicate } +# end +# +# # good +# describe 'cool feature' do +# it { cool_predicate } +# end +# +# describe 'another cool feature' do +# it { another_predicate } +# end +# +# # good +# context 'when case x', :tag do +# it { cool_predicate } +# end +# +# context 'when case y' do +# it { cool_predicate } +# end +# +# # good +# context Array do +# it { is_expected.to respond_to :each } +# end +# +# context Hash do +# it { is_expected.to respond_to :each } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:46 +class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:58 + def body(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:61 + def const_arg(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:55 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:68 + def on_begin(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:50 + def several_example_groups?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:64 + def skip_or_pending?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:89 + def add_repeated_lines(groups); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:98 + def message(group, repeats); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:78 + def repeated_group_bodies(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:94 + def signature_keys(group); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_body.rb:47 +RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated example group descriptions. +# +# @example +# +# # bad +# describe 'cool feature' do +# # example group +# end +# +# describe 'cool feature' do +# # example group +# end +# +# # bad +# context 'when case x' do +# # example group +# end +# +# describe 'when case x' do +# # example group +# end +# +# # good +# describe 'cool feature' do +# # example group +# end +# +# describe 'another cool feature' do +# # example group +# end +# +# # good +# context 'when case x' do +# # example group +# end +# +# context 'when another case' do +# # example group +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:46 +class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:55 + def doc_string_and_metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:65 + def empty_description?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:67 + def on_begin(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:50 + def several_example_groups?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:60 + def skip_or_pending?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:89 + def add_repeated_lines(groups); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:94 + def message(group, repeats); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:77 + def repeated_group_descriptions(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_example_group_description.rb:47 +RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String) + +# Check for repeated include of shared examples. +# +# @example +# +# # bad +# describe 'foo' do +# include_examples 'cool stuff' +# include_examples 'cool stuff' +# end +# +# # bad +# describe 'foo' do +# it_behaves_like 'a cool', 'thing' +# it_behaves_like 'a cool', 'thing' +# end +# +# # bad +# context 'foo' do +# it_should_behave_like 'a duck' +# it_should_behave_like 'a duck' +# end +# +# # good +# describe 'foo' do +# include_examples 'cool stuff' +# end +# +# describe 'bar' do +# include_examples 'cool stuff' +# end +# +# # good +# describe 'foo' do +# it_behaves_like 'a cool', 'thing' +# it_behaves_like 'a cool', 'person' +# end +# +# # good +# context 'foo' do +# it_should_behave_like 'a duck' +# it_should_behave_like 'a goose' +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:49 +class RuboCop::Cop::RSpec::RepeatedIncludeExample < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:59 + def include_examples?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:67 + def on_begin(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:54 + def several_include_examples?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:63 + def shared_examples_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:92 + def add_repeated_lines(items); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:87 + def literal_include_examples?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:101 + def message(item, repeats); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:77 + def repeated_include_examples(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:97 + def signature_keys(item); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/repeated_include_example.rb:50 +RuboCop::Cop::RSpec::RepeatedIncludeExample::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent style of stub's return setting. +# +# Enforces either `and_return` or block-style return in the cases +# where the returned value is constant. Ignores dynamic returned values +# are the result would be different +# +# This cop can be configured using the `EnforcedStyle` option +# +# @example `EnforcedStyle: and_return` (default) +# # bad +# allow(Foo).to receive(:bar) { "baz" } +# expect(Foo).to receive(:bar) { "baz" } +# +# # good +# allow(Foo).to receive(:bar).and_return("baz") +# expect(Foo).to receive(:bar).and_return("baz") +# # also good as the returned value is dynamic +# allow(Foo).to receive(:bar) { bar.baz } +# @example `EnforcedStyle: block` +# # bad +# allow(Foo).to receive(:bar).and_return("baz") +# expect(Foo).to receive(:bar).and_return("baz") +# +# # good +# allow(Foo).to receive(:bar) { "baz" } +# expect(Foo).to receive(:bar) { "baz" } +# # also good as the returned value is dynamic +# allow(Foo).to receive(:bar).and_return(bar.baz) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:36 +class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:51 + def and_return_value(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:45 + def contains_stub?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:62 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:55 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:48 + def stub_with_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:71 + def check_and_return_call(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:81 + def check_block_body(block); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:90 + def dynamic?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:95 +class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector + # @return [AndReturnCallCorrector] a new instance of AndReturnCallCorrector + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:96 + def initialize(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:102 + def call(corrector); end + + private + + # Returns the value of attribute arg. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:111 + def arg; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:133 + def hash_without_braces?; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:113 + def heredoc?; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:111 + def node; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:117 + def range; end + + # Returns the value of attribute receiver. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:111 + def receiver; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:125 + def replacement; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:139 +class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector + # @return [BlockBodyCorrector] a new instance of BlockBodyCorrector + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:140 + def initialize(block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:146 + def call(corrector); end + + private + + # Returns the value of attribute block. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:158 + def block; end + + # Returns the value of attribute body. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:158 + def body; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:160 + def heredoc?; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:158 + def node; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:164 +RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:40 +RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:41 +RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/return_from_stub.rb:42 +RuboCop::Cop::RSpec::ReturnFromStub::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for let scattered across the example group. +# +# Group lets together +# +# @example +# # bad +# describe Foo do +# let(:foo) { 1 } +# subject { Foo } +# let(:bar) { 2 } +# before { prepare } +# let!(:baz) { 3 } +# end +# +# # good +# describe Foo do +# subject { Foo } +# before { prepare } +# let(:foo) { 1 } +# let(:bar) { 2 } +# let!(:baz) { 3 } +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb:29 +class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb:34 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb:42 + def check_let_declarations(body); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb:57 + def find_first_let(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_let.rb:32 +RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String) + +# Checks for setup scattered across multiple hooks in an example group. +# +# Unify `before`, `after`, and `around` hooks when possible. +# +# @example +# # bad +# describe Foo do +# before { setup1 } +# before { setup2 } +# end +# +# # good +# describe Foo do +# before do +# setup1 +# setup2 +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb:25 +class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb:57 + def lines_msg(numbers); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb:29 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb:44 + def repeated_hooks(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/scattered_setup.rb:26 +RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String) + +# Checks for proper shared_context and shared_examples usage. +# +# If there are no examples defined, use shared_context. +# If there is no setup defined, use shared_examples. +# +# @example +# # bad +# RSpec.shared_context 'only examples here' do +# it 'does x' do +# end +# +# it 'does y' do +# end +# end +# +# # good +# RSpec.shared_examples 'only examples here' do +# it 'does x' do +# end +# +# it 'does y' do +# end +# end +# @example +# # bad +# RSpec.shared_examples 'only setup here' do +# subject(:foo) { :bar } +# +# let(:baz) { :bazz } +# +# before do +# something +# end +# end +# +# # good +# RSpec.shared_context 'only setup here' do +# subject(:foo) { :bar } +# +# let(:baz) { :bazz } +# +# before do +# something +# end +# end +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:53 +class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:64 + def context?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:60 + def examples?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:82 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:76 + def shared_context(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:79 + def shared_example(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:98 + def context_with_only_examples(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:102 + def examples_with_only_context(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:57 +RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_context.rb:56 +RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String) + +# Enforces use of string to titleize shared examples. +# +# @example +# # bad +# it_behaves_like :foo_bar_baz +# it_should_behave_like :foo_bar_baz +# shared_examples :foo_bar_baz +# shared_examples_for :foo_bar_baz +# include_examples :foo_bar_baz +# +# # good +# it_behaves_like 'foo bar baz' +# it_should_behave_like 'foo bar baz' +# shared_examples 'foo bar baz' +# shared_examples_for 'foo bar baz' +# include_examples 'foo bar baz' +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:23 +class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:32 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:27 + def shared_examples(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:45 +class RuboCop::Cop::RSpec::SharedExamples::Checker + # @return [Checker] a new instance of Checker + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:51 + def initialize(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:55 + def message; end + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:49 + def node; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:59 + def preferred_style; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:66 + def symbol; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:70 + def wrap_with_single_quotes(string); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/shared_examples.rb:46 +RuboCop::Cop::RSpec::SharedExamples::Checker::MSG = T.let(T.unsafe(nil), String) + +# Checks that chains of messages contain more than one element. +# +# @example +# # bad +# allow(foo).to receive_message_chain(:bar).and_return(42) +# +# # good +# allow(foo).to receive(:bar).and_return(42) +# +# # also good +# allow(foo).to receive(:bar, :baz) +# allow(foo).to receive("bar.baz") +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:19 +class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:27 + def message_chain(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:34 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:32 + def single_key_hash?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:49 + def autocorrect(corrector, node, method, arg); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:77 + def autocorrect_array_arg(corrector, arg); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:69 + def autocorrect_hash_arg(corrector, arg); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:83 + def key_to_arg(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:88 + def replacement(method); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:65 + def single_element_array?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:55 + def valid_usage?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:22 +RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/single_argument_message_chain.rb:24 +RuboCop::Cop::RSpec::SingleArgumentMessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that message expectations do not have a configured response. +# +# @example +# +# # bad +# expect(foo).to receive(:bar).with(42).and_return("hello world") +# +# # good (without spies) +# allow(foo).to receive(:bar).with(42).and_return("hello world") +# expect(foo).to receive(:bar).with(42) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:17 +class RuboCop::Cop::RSpec::StubbedMock < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:43 + def configured_response?(param0 = T.unsafe(nil)); end + + # Match expectation + # + # @example source that matches + # is_expected.to be_in_the_bar + # @example source that matches + # expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari) + # @example source that matches + # expect_any_instance_of(Officer).to be_alert + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] expectation, method name, matcher + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:62 + def expectation(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response in block-pass + # + # @example source that matches + # receive(:foo, &canned) + # @example source that matches + # receive_message_chain(:foo, :bar, &canned) + # @example source that matches + # receive(:foo).with('bar', &canned) + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:130 + def matcher_with_blockpass(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response + # + # @example source that matches + # receive(:foo).and_return('bar') + # @example source that matches + # receive(:lower).and_raise(SomeError) + # @example source that matches + # receive(:redirect).and_call_original + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:82 + def matcher_with_configured_response(param0 = T.unsafe(nil)); end + + # Match matcher with a configured response defined as a hash + # + # @example source that matches + # receive_messages(foo: 'bar', baz: 'qux') + # @example source that matches + # receive_message_chain(:foo, bar: 'baz') + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:109 + def matcher_with_hash(param0 = T.unsafe(nil)); end + + # Match matcher with a return block + # + # @example source that matches + # receive(:foo) { 'bar' } + # @param node [RuboCop::AST::Node] + # @yield [RuboCop::AST::Node] matcher + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:94 + def matcher_with_return_block(param0 = T.unsafe(nil)); end + + # Match message expectation matcher + # + # @example source that matches + # receive(:foo) + # @example source that matches + # receive_message_chain(:foo, :bar) + # @example source that matches + # receive(:foo).with('bar') + # @param node [RuboCop::AST::Node] + # @return [Array<RuboCop::AST::Node>] matching nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:35 + def message_expectation?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:137 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:154 + def msg(method_name); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:143 + def on_expectation(expectation, method_name, matcher); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:160 + def replacement(method_name); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/stubbed_mock.rb:18 +RuboCop::Cop::RSpec::StubbedMock::MSG = T.let(T.unsafe(nil), String) + +# Ensure that subject is defined using subject helper. +# +# @example +# +# # bad +# let(:subject) { foo } +# let!(:subject) { foo } +# subject(:subject) { foo } +# subject!(:subject) { foo } +# +# # bad +# block = -> {} +# let(:subject, &block) +# +# # good +# subject(:test_subject) { foo } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:23 +class RuboCop::Cop::RSpec::SubjectDeclaration < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:28 + def offensive_subject_declaration?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:32 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:41 + def message_for(offense); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:24 +RuboCop::Cop::RSpec::SubjectDeclaration::MSG_LET = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_declaration.rb:25 +RuboCop::Cop::RSpec::SubjectDeclaration::MSG_REDUNDANT = T.let(T.unsafe(nil), String) + +# Checks for stubbed test subjects. +# +# Checks nested subject stubs for innermost subject definition +# when subject is also defined in parent example groups. +# +# @example +# # bad +# describe Article do +# subject(:article) { Article.new } +# +# it 'indicates that the author is unknown' do +# allow(article).to receive(:author).and_return(nil) +# expect(article.description).to include('by an unknown author') +# end +# end +# +# # bad +# describe Article do +# subject(:foo) { Article.new } +# +# context 'nested subject' do +# subject(:article) { Article.new } +# +# it 'indicates that the author is unknown' do +# allow(article).to receive(:author).and_return(nil) +# expect(article.description).to include('by an unknown author') +# end +# end +# end +# +# # good +# describe Article do +# subject(:article) { Article.new(author: nil) } +# +# it 'indicates that the author is unknown' do +# expect(article.description).to include('by an unknown author') +# end +# end +# @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test +# @see https://samphippen.com/introducing-rspec-smells-and-where-to-find-them#smell-1-stubject +# @see https://github.com/rubocop-hq/rspec-style-guide#dont-stub-subject +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:51 +class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RSpec::TopLevelGroup + + # Find a memoized helper + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:81 + def let?(param0 = T.unsafe(nil)); end + + # Match `allow` and `expect(...).to receive` + # + # @example source that matches + # allow(foo).to receive(:bar) + # allow(foo).to receive(:bar).with(1) + # allow(foo).to receive(:bar).with(1).and_return(2) + # expect(foo).to receive(:bar) + # expect(foo).to receive(:bar).with(1) + # expect(foo).to receive(:bar).with(1).and_return(2) + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:98 + def message_expectation?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:110 + def message_expectation_matcher?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:116 + def on_top_level_group(node); end + + # Find a named or unnamed subject definition + # + # @example anonymous subject + # subject?(parse('subject { foo }').ast) do |name| + # name # => :subject + # end + # @example named subject + # subject?(parse('subject(:thing) { foo }').ast) do |name| + # name # => :thing + # end + # @param node [RuboCop::AST::Node] + # @yield [Symbol] subject name + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:72 + def subject?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:127 + def find_all_explicit(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:141 + def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/subject_stub.rb:54 +RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String) + +# Helper methods for top level example group cops +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:7 +module RuboCop::Cop::RSpec::TopLevelGroup + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:10 + def on_new_investigation; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:19 + def top_level_groups; end + + private + + # Dummy methods to be overridden in the consumer + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:27 + def on_top_level_example_group(_node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:29 + def on_top_level_group(_node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:48 + def root_node; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:31 + def top_level_group?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/top_level_group.rb:35 + def top_level_nodes(node); end +end + +# Checks for a specified error in checking raised errors. +# +# Enforces one of an Exception type, a string, or a regular +# expression to match against the exception message as a parameter +# to `raise_error` +# +# @example +# +# # bad +# expect { +# raise StandardError.new('error') +# }.to raise_error +# +# # good +# expect { +# raise StandardError.new('error') +# }.to raise_error(StandardError) +# +# expect { +# raise StandardError.new('error') +# }.to raise_error('error') +# +# expect { +# raise StandardError.new('error') +# }.to raise_error(/err/) +# +# expect { do_something }.not_to raise_error +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:33 +class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Base + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:57 + def block_with_args?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:53 + def empty_exception_matcher?(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:38 + def empty_raise_error_or_exception(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:47 + def on_send(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:34 +RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/unspecified_exception.rb:35 +RuboCop::Cop::RSpec::UnspecifiedException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Helps check offenses with variable definitions +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb:7 +module RuboCop::Cop::RSpec::Variable + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb:14 + def variable_definition?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb:11 +RuboCop::Cop::RSpec::Variable::Helpers = RuboCop::RSpec::Language::Helpers + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/mixin/variable.rb:10 +RuboCop::Cop::RSpec::Variable::Subjects = RuboCop::RSpec::Language::Subjects + +# Checks that memoized helpers names are symbols or strings. +# +# @example EnforcedStyle: symbols (default) +# # bad +# subject('user') { create_user } +# let('user_name') { 'Adam' } +# +# # good +# subject(:user) { create_user } +# let(:user_name) { 'Adam' } +# @example EnforcedStyle: strings +# # bad +# subject(:user) { create_user } +# let(:user_name) { 'Adam' } +# +# # good +# subject('user') { create_user } +# let('user_name') { 'Adam' } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:25 +class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RSpec::Variable + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:32 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:47 + def correct_variable(variable); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:63 + def string?(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:58 + def style_violation?(variable); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:67 + def symbol?(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_definition.rb:30 +RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks that memoized helper names use the configured style. +# +# Variables can be excluded from checking using the `IgnoredPatterns` +# option. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# subject(:userName1) { 'Adam' } +# let(:userName2) { 'Adam' } +# +# # good +# subject(:user_name_1) { 'Adam' } +# let(:user_name_2) { 'Adam' } +# @example EnforcedStyle: camelCase +# # bad +# subject(:user_name_1) { 'Adam' } +# let(:user_name_2) { 'Adam' } +# +# # good +# subject(:userName1) { 'Adam' } +# let(:userName2) { 'Adam' } +# @example IgnoredPatterns configuration +# +# # rubocop.yml +# # RSpec/VariableName: +# # EnforcedStyle: snake_case +# # IgnoredPatterns: +# # - ^userFood +# @example +# # okay because it matches the `^userFood` regex in `IgnoredPatterns` +# subject(:userFood_1) { 'spaghetti' } +# let(:userFood_2) { 'fettuccine' } +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb:42 +class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RSpec::Variable + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb:49 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb:60 + def message(style); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/variable_name.rb:47 +RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent verified double reference style. +# +# Only investigates references that are one of the supported styles. +# +# This cop can be configured in your configuration using the +# `EnforcedStyle` option and supports `--auto-gen-config`. +# +# @example `EnforcedStyle: constant` (default) +# # bad +# let(:foo) do +# instance_double('ClassName', method_name: 'returned_value') +# end +# +# # good +# let(:foo) do +# instance_double(ClassName, method_name: 'returned_value') +# end +# @example `EnforcedStyle: string` +# # bad +# let(:foo) do +# instance_double(ClassName, method_name: 'returned_value') +# end +# +# # good +# let(:foo) do +# instance_double('ClassName', method_name: 'returned_value') +# end +# @example Reference is not in the supported style list. No enforcement +# +# # good +# let(:foo) do +# instance_double(@klass, method_name: 'returned_value') +# end +# @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:43 +class RuboCop::Cop::RSpec::VerifiedDoubleReference < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:74 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:66 + def verified_double(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:101 + def correct_style(violation); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:92 + def opposing_style?(class_reference); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:47 +RuboCop::Cop::RSpec::VerifiedDoubleReference::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:60 +RuboCop::Cop::RSpec::VerifiedDoubleReference::REFERENCE_TYPE_STYLES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_double_reference.rb:49 +RuboCop::Cop::RSpec::VerifiedDoubleReference::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Prefer using verifying doubles over normal doubles. +# +# @example +# # bad +# let(:foo) do +# double(method_name: 'returned value') +# end +# +# # bad +# let(:foo) do +# double("ClassName", method_name: 'returned value') +# end +# +# # good +# let(:foo) do +# instance_double("ClassName", method_name: 'returned value') +# end +# @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:25 +class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:34 + def on_send(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:30 + def unverified_double(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:45 + def symbol?(name); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:26 +RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/verified_doubles.rb:27 +RuboCop::Cop::RSpec::VerifiedDoubles::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks void `expect()`. +# +# @example +# # bad +# expect(something) +# +# # good +# expect(something).to be(1) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:14 +class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Base + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:20 + def expect?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:25 + def expect_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:35 + def on_block(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:29 + def on_send(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:43 + def check_expect(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:49 + def void?(expect); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:15 +RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/void_expect.rb:17 +RuboCop::Cop::RSpec::VoidExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for calling a block within a stub. +# +# @example +# # bad +# allow(foo).to receive(:bar) { |&block| block.call(1) } +# +# # good +# expect(foo).to receive(:bar).and_yield(1) +# +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:14 +class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:24 + def block_arg(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:27 + def block_call?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:21 + def method_on_stub?(param0); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:29 + def on_block(node); end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:45 + def autocorrect(corrector, node, range); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:60 + def block_range(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:52 + def calling_block?(node, block); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:72 + def convert_block_to_yield(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:64 + def generate_replacement(node); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/cop/rspec/yield.rb:18 +RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String) + +module RuboCop::Cop::Style; end + +# Checks for trailing comma in argument lists. +# The supported styles are: +# +# * `consistent_comma`: Requires a comma after the last argument, +# for all parenthesized method calls with arguments. +# * `comma`: Requires a comma after the last argument, but only for +# parenthesized method calls where each argument is on its own line. +# * `no_comma`: Requires that there is no comma after the last +# argument. +# +# @example EnforcedStyleForMultiline: consistent_comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # bad +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, +# 3 +# ) +# +# # bad +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, 2, 3 +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: no_comma (default) +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, +# 2 +# ) +class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_arguments.rb:91 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_arguments.rb:91 + def on_send(node); end + + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop-rspec.rb:51 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb:4 +module RuboCop::RSpec; end + +# Shared behavior for aligning braces for single line lets +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:6 +class RuboCop::RSpec::AlignLetBrace + include ::RuboCop::RSpec::Language + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + + # @return [AlignLetBrace] a new instance of AlignLetBrace + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:10 + def initialize(root, token); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:21 + def indent_for(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:15 + def offending_tokens; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:43 + def adjacent_let_chunks; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:35 + def let_group_for(let); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:27 + def let_token(node); end + + # Returns the value of attribute root. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:60 + def root; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:53 + def single_line_lets; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:31 + def target_column_for(let); end + + # Returns the value of attribute token. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/align_let_brace.rb:60 + def token; end +end + +# Wrapper for RSpec DSL methods +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:6 +class RuboCop::RSpec::Concept + include ::RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::RSpec::Language::NodePattern + + # @return [Concept] a new instance of Concept + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:11 + def initialize(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:15 + def ==(other); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:15 + def eql?(other); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:21 + def hash; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:25 + def to_node; end + + protected + + # Returns the value of attribute node. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/concept.rb:31 + def node; end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:5 +module RuboCop::RSpec::Corrector; end + +# Helper methods to move a node +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:7 +class RuboCop::RSpec::Corrector::MoveNode + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RSpec::FinalEndLocation + include ::RuboCop::Cop::RSpec::CommentsHelp + + # @return [MoveNode] a new instance of MoveNode + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:14 + def initialize(node, corrector, processed_source); end + + # Returns the value of attribute corrector. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:12 + def corrector; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:27 + def move_after(other); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:20 + def move_before(other); end + + # Returns the value of attribute original. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:12 + def original; end + + # Returns the value of attribute processed_source. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:12 + def processed_source; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:40 + def node_range(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:44 + def node_range_with_surrounding_space(node); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/corrector/move_node.rb:36 + def source(node); end +end + +# Wrapper for RSpec examples +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:7 +class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:28 + def definition; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:16 + def doc_string; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:8 + def extract_doc_string(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:14 + def extract_implementation(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:11 + def extract_metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:24 + def implementation; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example.rb:20 + def metadata; end +end + +# Wrapper for RSpec example groups +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:12 +class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:30 + def examples; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:36 + def hooks; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:22 + def lets; end + + # Detect if the node is an example group or shared example + # + # Selectors which indicate that we should stop searching + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:13 + def scope_change?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:26 + def subjects; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:58 + def find_all(node, predicate); end + + # Recursively search for predicate within the current scope + # + # Searches node and halts when a scope change is detected + # + # @param node [RuboCop::AST::Node] node to recursively search + # @param predicate [Symbol] method to call with node as argument + # @return [Array<RuboCop::AST::Node>] discovered nodes + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/example_group.rb:52 + def find_all_in_scope(node, predicate); end +end + +# RuboCop FactoryBot project namespace +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb:5 +module RuboCop::RSpec::FactoryBot + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:55 + def attribute_defining_methods; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:59 + def reserved_methods; end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:7 +RuboCop::RSpec::FactoryBot::ATTRIBUTE_DEFINING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:30 +RuboCop::RSpec::FactoryBot::DEFINITION_PROXY_METHODS = T.let(T.unsafe(nil), Array) + +# Contains node matchers for common FactoryBot DSL. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb:7 +module RuboCop::RSpec::FactoryBot::Language + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot/language.rb:11 + def factory_bot?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:43 +RuboCop::RSpec::FactoryBot::RESERVED_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/factory_bot.rb:15 +RuboCop::RSpec::FactoryBot::UNPROXIED_METHODS = T.let(T.unsafe(nil), Array) + +# Wrapper for RSpec hook +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:7 +class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:24 + def example?; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:8 + def extract_metadata(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:18 + def knowable_scope?; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:38 + def metadata; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:14 + def name; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:28 + def scope; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:74 + def scope_argument; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:70 + def scope_name; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:51 + def transform_metadata(meta); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:66 + def transform_true(node); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/hook.rb:47 + def valid_scope?(node); end +end + +# Because RuboCop doesn't yet support plugins, we have to monkey patch in a +# bit of our configuration. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/inject.rb:7 +module RuboCop::RSpec::Inject + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/inject.rb:8 + def defaults!; end + end +end + +# Contains node matchers for common RSpec DSL. +# +# RSpec allows for configuring aliases for commonly used DSL elements, e.g. +# example groups and hooks. It is possible to configure RuboCop RSpec to +# be able to properly detect these elements in the `RSpec/Language` section +# of the RuboCop YAML configuration file. +# +# In addition to providing useful matchers, this class is responsible for +# using the configured aliases. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb:5 +module RuboCop::RSpec::Language + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::RSpec::Language::NodePattern + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:41 + def example?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:26 + def example_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:36 + def example_group_with_body?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:44 + def hook?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:55 + def include?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:47 + def let?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:23 + def rspec?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:29 + def shared_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:32 + def spec_group?(param0 = T.unsafe(nil)); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:63 + def subject?(param0 = T.unsafe(nil)); end + + class << self + # Returns the value of attribute config. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:19 + def config; end + + # Sets the attribute config + # + # @param value the value to set the attribute config to. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:19 + def config=(_arg0); end + end +end + +# This is used in Dialect and DescribeClass cops to detect RSpec blocks. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:185 +module RuboCop::RSpec::Language::ALL + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:186 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:65 +module RuboCop::RSpec::Language::ExampleGroups + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:67 + def all(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:77 + def focused(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:73 + def regular(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:81 + def skipped(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:87 +module RuboCop::RSpec::Language::Examples + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:89 + def all(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:100 + def focused(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:108 + def pending(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:96 + def regular(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:104 + def skipped(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:114 +module RuboCop::RSpec::Language::Expectations + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:115 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:120 +module RuboCop::RSpec::Language::Helpers + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:121 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:132 +module RuboCop::RSpec::Language::HookScopes + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:133 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:126 +module RuboCop::RSpec::Language::Hooks + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:127 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:138 +module RuboCop::RSpec::Language::Includes + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:140 + def all(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:149 + def context(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:145 + def examples(element); end + end +end + +# Helper methods to detect RSpec DSL used with send and block +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb:7 +module RuboCop::RSpec::Language::NodePattern + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb:12 + def block_pattern(string); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language/node_pattern.rb:8 + def send_pattern(string); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:155 +module RuboCop::RSpec::Language::Runners + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:156 + def all(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:161 +module RuboCop::RSpec::Language::SharedGroups + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:163 + def all(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:172 + def context(element); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:168 + def examples(element); end + end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:178 +module RuboCop::RSpec::Language::Subjects + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/language.rb:179 + def all(element); end + end +end + +# RuboCop RSpec specific extensions of RuboCop::AST::Node +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/node.rb:6 +module RuboCop::RSpec::Node + # In various cops we want to regard const as literal although it's not + # strictly literal. + # + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/node.rb:9 + def recursive_literal_or_const?; end +end + +# Version information for the RSpec RuboCop plugin. +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb:6 +module RuboCop::RSpec::Version; end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/version.rb:7 +RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String) + +# RSpec example wording rewriter +# +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:6 +class RuboCop::RSpec::Wording + # @return [Wording] a new instance of Wording + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:12 + def initialize(text, ignore:, replace:); end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:18 + def rewrite; end + + private + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:72 + def append_suffix(word, suffix); end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:57 + def ignored_word?(word); end + + # Returns the value of attribute ignores. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:31 + def ignores; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:43 + def remove_should_and_pluralize; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:33 + def replace_prefix(pattern, replacement); end + + # Returns the value of attribute replacements. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:31 + def replacements; end + + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:61 + def substitute(word); end + + # Returns the value of attribute text. + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:31 + def text; end + + # @return [Boolean] + # + # source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:39 + def uppercase?(word); end +end + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:9 +RuboCop::RSpec::Wording::ES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:10 +RuboCop::RSpec::Wording::IES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:8 +RuboCop::RSpec::Wording::SHOULDNT_BE_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-rspec-2.12.1/lib/rubocop/rspec/wording.rb:7 +RuboCop::RSpec::Wording::SHOULDNT_PREFIX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token diff --git a/sorbet/rbi/gems/rubocop-sorbet.rbi b/sorbet/rbi/gems/rubocop-sorbet.rbi deleted file mode 100644 index 629feee8..00000000 --- a/sorbet/rbi/gems/rubocop-sorbet.rbi +++ /dev/null @@ -1,218 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-sorbet/all/rubocop-sorbet.rbi -# -# rubocop-sorbet-0.6.11 - -module RuboCop -end -module RuboCop::Sorbet -end -class RuboCop::Sorbet::Error < StandardError -end -module RuboCop::Sorbet::Inject - def self.defaults!; end -end -module RuboCop::Cop -end -module RuboCop::Cop::Sorbet -end -class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop - def autocorrect(node); end - def binding_unaliased_type?(param0 = nil); end - def dynamic_type_creation_with_block?(param0 = nil); end - def generic_parameter_decl_block_call?(param0 = nil); end - def generic_parameter_decl_call?(param0 = nil); end - def method_needing_aliasing_on_t?(param0); end - def not_dynamic_type_creation_with_block?(node); end - def not_generic_parameter_decl?(node); end - def not_nil?(node); end - def not_t_let?(node); end - def on_casgn(node); end - def t_let?(param0 = nil); end - def using_deprecated_type_alias_syntax?(param0 = nil); end - def using_type_alias?(param0 = nil); end -end -class RuboCop::Cop::Sorbet::ConstantsFromStrings < RuboCop::Cop::Cop - def constant_from_string?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < RuboCop::Cop::Cop - def not_lit_const_superclass?(param0 = nil); end - def on_class(node); end -end -class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral < RuboCop::Cop::Cop - def autocorrect(node); end - def initialize(*arg0); end - def not_lit_const_include?(param0 = nil); end - def on_send(node); end - def used_names; end - def used_names=(arg0); end -end -class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < RuboCop::Cop::Cop - def on_class(node); end - def subclass_of_t_struct?(param0 = nil); end - def t_nilable_untyped(param0 = nil); end - def t_struct(param0 = nil); end - def t_untyped(param0 = nil); end - def untyped_props(param0); end -end -class RuboCop::Cop::Sorbet::OneAncestorPerLine < RuboCop::Cop::Cop - def abstract?(param0); end - def autocorrect(node); end - def more_than_one_ancestor(param0 = nil); end - def new_ra_line(indent_count); end - def on_class(node); end - def on_module(node); end - def process_node(node); end - def requires_ancestors(param0); end -end -class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < RuboCop::Cop::Cop - def autocorrect(node); end - def on_send(node); end -end -class RuboCop::Cop::Sorbet::ForbidTUnsafe < RuboCop::Cop::Cop - def on_send(node); end - def t_unsafe?(param0 = nil); end -end -class RuboCop::Cop::Sorbet::ForbidTUntyped < RuboCop::Cop::Cop - def on_send(node); end - def t_untyped?(param0 = nil); end -end -class RuboCop::Cop::Sorbet::TypeAliasName < RuboCop::Cop::Cop - def casgn_type_alias?(param0 = nil); end - def on_casgn(node); end -end -class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop - def autocorrect(node); end - def extend_t_helpers?(param0 = nil); end - def extend_t_sig?(param0 = nil); end - def on_send(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop - def allowed_paths; end - def investigate(processed_source); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop - def autocorrect(node); end - def convert_newlines(source); end - def on_class(node); end - def on_module(node); end - def process_node(node); end -end -class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < RuboCop::Cop::Cop - def allow_incompatible?(param0); end - def allow_incompatible_override?(param0 = nil); end - def not_nil?(node); end - def on_send(node); end - def sig?(param0); end -end -class RuboCop::Cop::Sorbet::SignatureCop < RuboCop::Cop::Cop - def allowed_recv(recv); end - def on_block(node); end - def on_signature(_); end - def signature?(param0 = nil); end - def with_runtime?(param0 = nil); end - def without_runtime?(param0 = nil); end -end -class RuboCop::Cop::Sorbet::CheckedTrueInSignature < RuboCop::Cop::Sorbet::SignatureCop - def offending_node(param0); end - def on_signature(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < RuboCop::Cop::Sorbet::SignatureCop - def check_order_for_kwoptargs(parameters); end - def on_signature(node); end -end -class RuboCop::Cop::Sorbet::SignatureBuildOrder < RuboCop::Cop::Sorbet::SignatureCop - def autocorrect(node); end - def call_chain(sig_child_node); end - def can_autocorrect?; end - def node_reparsed_with_modern_features(node); end - def on_signature(node); end - def root_call(param0); end -end -class RuboCop::Cop::Sorbet::SignatureBuildOrder::ModernBuilder < RuboCop::AST::Builder -end -class RuboCop::Cop::Sorbet::EnforceSignatures < RuboCop::Cop::Sorbet::SignatureCop - def accessor?(param0 = nil); end - def autocorrect(node); end - def check_node(node); end - def initialize(config = nil, options = nil); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def on_signature(node); end - def param_type_placeholder; end - def return_type_placeholder; end - def scope(node); end -end -class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion - def generate_params; end - def generate_return; end - def initialize(indent, param_placeholder, return_placeholder); end - def params; end - def params=(arg0); end - def returns; end - def returns=(arg0); end - def to_autocorrect; end -end -class RuboCop::Cop::Sorbet::ValidSigil < RuboCop::Cop::Cop - def autocorrect(_node); end - def check_sigil_present(sigil); end - def check_strictness_level(sigil, strictness); end - def check_strictness_not_empty(sigil, strictness); end - def check_strictness_valid(sigil, strictness); end - def extract_sigil(processed_source); end - def extract_strictness(sigil); end - def investigate(processed_source); end - def minimum_strictness; end - def require_sigil_on_all_files?; end - def suggested_strictness; end - def suggested_strictness_level(minimum_strictness, suggested_strictness); end -end -class RuboCop::Cop::Sorbet::HasSigil < RuboCop::Cop::Sorbet::ValidSigil - def require_sigil_on_all_files?; end -end -class RuboCop::Cop::Sorbet::IgnoreSigil < RuboCop::Cop::Sorbet::HasSigil - def minimum_strictness; end -end -class RuboCop::Cop::Sorbet::FalseSigil < RuboCop::Cop::Sorbet::HasSigil - def minimum_strictness; end -end -class RuboCop::Cop::Sorbet::TrueSigil < RuboCop::Cop::Sorbet::HasSigil - def minimum_strictness; end -end -class RuboCop::Cop::Sorbet::StrictSigil < RuboCop::Cop::Sorbet::HasSigil - def minimum_strictness; end -end -class RuboCop::Cop::Sorbet::StrongSigil < RuboCop::Cop::Sorbet::HasSigil - def minimum_strictness; end -end -class RuboCop::Cop::Sorbet::EnforceSigilOrder < RuboCop::Cop::Sorbet::ValidSigil - def autocorrect(_node); end - def check_magic_comments_order(tokens); end - def extract_magic_comments(processed_source); end - def investigate(processed_source); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Sorbet::EnforceSingleSigil < RuboCop::Cop::Sorbet::ValidSigil - def autocorrect(_node); end - def extract_all_sigils(processed_source); end - def investigate(processed_source); end - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour - def on_assignment(value); end - def self.prepended(base); end -end -class RuboCop::Cop::Style::MutableConstant < RuboCop::Cop::Base - def t_let(param0 = nil); end -end diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi new file mode 100644 index 00000000..fb976c92 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-sorbet@0.6.11.rbi @@ -0,0 +1,1013 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-sorbet` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-sorbet`. + +# Correct superclass `send` expressions by constant literals. +# +# Sorbet, the static checker, is not (yet) able to support constructs on the +# following form: +# +# ```ruby +# class Foo < send_expr; end +# ``` +# +# Multiple occurences of this can be found in Shopify's code base like: +# +# ```ruby +# class ShopScope < Component::TrustedIdScope[ShopIdentity::ShopId] +# ``` +# or +# ```ruby +# class ApiClientEligibility < Struct.new(:api_client, :match_results, :shop) +# ``` +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb:2 +module RuboCop; end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:6 +module RuboCop::Cop; end + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:33 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:46 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:7 +module RuboCop::Cop::Sorbet; end + +# This cop disallows using `.override(allow_incompatible: true)`. +# Using `allow_incompatible` suggests a violation of the Liskov +# Substitution Principle, meaning that a subclass is not a valid +# subtype of it's superclass. This Cop prevents these design smells +# from occurring. +# +# @example +# +# # bad +# sig.override(allow_incompatible: true) +# +# # good +# sig.override +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:21 +class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:35 + def allow_incompatible?(param0); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:39 + def allow_incompatible_override?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:31 + def not_nil?(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:48 + def on_send(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:22 + def sig?(param0); end +end + +# This cop disallows binding the return value of `T.any`, `T.all`, `T.enum` +# to a constant directly. To bind the value, one must use `T.type_alias`. +# +# @example +# +# # bad +# FooOrBar = T.any(Foo, Bar) +# +# # good +# FooOrBar = T.type_alias { T.any(Foo, Bar) } +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:18 +class RuboCop::Cop::Sorbet::BindingConstantWithoutTypeAlias < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:116 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:19 + def binding_unaliased_type?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:51 + def dynamic_type_creation_with_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:66 + def generic_parameter_decl_block_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:60 + def generic_parameter_decl_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:72 + def method_needing_aliasing_on_t?(param0); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:85 + def not_dynamic_type_creation_with_block?(node); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:89 + def not_generic_parameter_decl?(node); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:93 + def not_nil?(node); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:81 + def not_t_let?(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:97 + def on_casgn(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:41 + def t_let?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:32 + def using_deprecated_type_alias_syntax?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/binding_constants_without_type_alias.rb:23 + def using_type_alias?(param0 = T.unsafe(nil)); end +end + +# This cop ensures that callback conditionals are bound to the right type +# so that they are type checked properly. +# +# Auto-correction is unsafe because other libraries define similar style callbacks as Rails, but don't always need +# binding to the attached class. Auto-correcting those usages can lead to false positives and auto-correction +# introduces new typing errors. +# +# @example +# +# # bad +# class Post < ApplicationRecord +# before_create :do_it, if: -> { should_do_it? } +# +# def should_do_it? +# true +# end +# end +# +# # good +# class Post < ApplicationRecord +# before_create :do_it, if: -> { +# T.bind(self, Post) +# should_do_it? +# } +# +# def should_do_it? +# true +# end +# end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb:35 +class RuboCop::Cop::Sorbet::CallbackConditionalsBinding < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb:47 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb:99 + def on_send(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/callback_conditionals_binding.rb:36 +RuboCop::Cop::Sorbet::CallbackConditionalsBinding::CALLBACKS = T.let(T.unsafe(nil), Array) + +# This cop disallows the usage of `checked(true)`. This usage could cause +# confusion; it could lead some people to believe that a method would be checked +# even if runtime checks have not been enabled on the class or globally. +# Additionally, in the event where checks are enabled, `checked(true)` would +# be redundant; only `checked(false)` or `soft` would change the behaviour. +# +# @example +# +# # bad +# sig { void.checked(true) } +# +# # good +# sig { void } +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb:22 +class RuboCop::Cop::Sorbet::CheckedTrueInSignature < ::RuboCop::Cop::Sorbet::SignatureCop + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb:25 + def offending_node(param0); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb:36 + def on_signature(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb:29 +RuboCop::Cop::Sorbet::CheckedTrueInSignature::MESSAGE = T.let(T.unsafe(nil), String) + +# This cop disallows the calls that are used to get constants fom Strings +# such as +constantize+, +const_get+, and +constants+. +# +# The goal of this cop is to make the code easier to statically analyze, +# more IDE-friendly, and more predictable. It leads to code that clearly +# expresses which values the constant can have. +# +# @example +# +# # bad +# class_name.constantize +# +# # bad +# constants.detect { |c| c.name == "User" } +# +# # bad +# const_get(class_name) +# +# # good +# case class_name +# when "User" +# User +# else +# raise ArgumentError +# end +# +# # good +# { "User" => User }.fetch(class_name) +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb:36 +class RuboCop::Cop::Sorbet::ConstantsFromStrings < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb:37 + def constant_from_string?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/constants_from_strings.rb:41 + def on_send(node); end +end + +# This cop checks that the Sorbet sigil comes as the first magic comment in the file. +# +# The expected order for magic comments is: typed, (en)?coding, warn_indent then frozen_string_literal. +# +# For example, the following bad ordering: +# +# ```ruby +# class Foo; end +# ``` +# +# Will be corrected as: +# +# ```ruby +# class Foo; end +# ``` +# +# Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered, +# other comments or magic comments are left in the same place. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:30 +class RuboCop::Cop::Sorbet::EnforceSigilOrder < ::RuboCop::Cop::Sorbet::ValidSigil + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:42 + def autocorrect(_node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:33 + def investigate(processed_source); end + + protected + + # checks + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:91 + def check_magic_comments_order(tokens); end + + # Get all the tokens in `processed_source` that match `MAGIC_REGEX` + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:83 + def extract_magic_comments(processed_source); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:67 +RuboCop::Cop::Sorbet::EnforceSigilOrder::CODING_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:69 +RuboCop::Cop::Sorbet::EnforceSigilOrder::FROZEN_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:68 +RuboCop::Cop::Sorbet::EnforceSigilOrder::INDENT_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:78 +RuboCop::Cop::Sorbet::EnforceSigilOrder::MAGIC_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb:71 +RuboCop::Cop::Sorbet::EnforceSigilOrder::PREFERRED_ORDER = T.let(T.unsafe(nil), Hash) + +# This cop checks that every method definition and attribute accessor has a Sorbet signature. +# +# It also suggest an autocorrect with placeholders so the following code: +# +# ``` +# def foo(a, b, c); end +# ``` +# +# Will be corrected as: +# +# ``` +# sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped) +# def foo(a, b, c); end +# ``` +# +# You can configure the placeholders used by changing the following options: +# +# * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped') +# * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped') +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:29 +class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Sorbet::SignatureCop + # @return [EnforceSignatures] a new instance of EnforceSignatures + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:30 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:35 + def accessor?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:55 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:39 + def on_def(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:43 + def on_defs(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:47 + def on_send(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:51 + def on_signature(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:74 + def scope(node); end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:82 + def check_node(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:93 + def param_type_placeholder; end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:97 + def return_type_placeholder; end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:101 +class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion + # @return [SigSuggestion] a new instance of SigSuggestion + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:104 + def initialize(indent, param_placeholder, return_placeholder); end + + # Returns the value of attribute params. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:102 + def params; end + + # Sets the attribute params + # + # @param value the value to set the attribute params to. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:102 + def params=(_arg0); end + + # Returns the value of attribute returns. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:102 + def returns; end + + # Sets the attribute returns + # + # @param value the value to set the attribute returns to. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:102 + def returns=(_arg0); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:112 + def to_autocorrect; end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:124 + def generate_params; end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:135 + def generate_return; end +end + +# This cop checks that there is only one Sorbet sigil in a given file +# +# For example, the following class with two sigils +# +# ```ruby +# class Foo; end +# ``` +# +# Will be corrected as: +# +# ```ruby +# class Foo; end +# ``` +# +# Other comments or magic comments are left in place. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb:26 +class RuboCop::Cop::Sorbet::EnforceSingleSigil < ::RuboCop::Cop::Sorbet::ValidSigil + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb:39 + def autocorrect(_node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb:29 + def investigate(processed_source); end + + protected + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb:55 + def extract_all_sigils(processed_source); end +end + +# This cop makes the Sorbet `false` sigil mandatory in all files. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/false_sigil.rb:10 +class RuboCop::Cop::Sorbet::FalseSigil < ::RuboCop::Cop::Sorbet::HasSigil + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/false_sigil.rb:11 + def minimum_strictness; end +end + +# This cop ensures RBI shims do not include a call to extend T::Sig +# or to extend T::Helpers +# +# @example +# +# # bad +# module SomeModule +# extend T::Sig +# extend T::Helpers +# +# sig { returns(String) } +# def foo; end +# end +# +# # good +# module SomeModule +# sig { returns(String) } +# def foo; end +# end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:25 +class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims < ::RuboCop::Cop::Cop + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:39 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:35 + def extend_t_helpers?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:31 + def extend_t_sig?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:47 + def on_send(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:28 +RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_extend_t_sig_helpers_in_shims.rb:29 +RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:29 +class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral < ::RuboCop::Cop::Cop + # @return [ForbidIncludeConstLiteral] a new instance of ForbidIncludeConstLiteral + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:40 + def initialize(*_arg0); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:56 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:34 + def not_lit_const_include?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:45 + def on_send(node); end + + # Returns the value of attribute used_names. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:32 + def used_names; end + + # Sets the attribute used_names + # + # @param value the value to set the attribute used_names to. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:32 + def used_names=(_arg0); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_include_const_literal.rb:30 +RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral::MSG = T.let(T.unsafe(nil), String) + +# This cop makes sure that RBI files are always located under the defined allowed paths. +# +# Options: +# +# * `AllowedPaths`: A list of the paths where RBI files are allowed (default: ["sorbet/rbi/**"]) +# +# @example +# # bad +# # lib/some_file.rbi +# # other_file.rbi +# +# # good +# # sorbet/rbi/some_file.rbi +# # sorbet/rbi/any/path/for/file.rbi +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb:22 +class RuboCop::Cop::Sorbet::ForbidRBIOutsideOfAllowedPaths < ::RuboCop::Cop::Cop + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb:25 + def investigate(processed_source); end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb:57 + def allowed_paths; end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb:27 +class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb:30 + def not_lit_const_superclass?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb:38 + def on_class(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb:28 +RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::MSG = T.let(T.unsafe(nil), String) + +# This cop disallows using `T.unsafe` anywhere. +# +# @example +# +# # bad +# T.unsafe(foo) +# +# # good +# foo +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb:17 +class RuboCop::Cop::Sorbet::ForbidTUnsafe < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb:20 + def on_send(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_unsafe.rb:18 + def t_unsafe?(param0 = T.unsafe(nil)); end +end + +# This cop disallows using `T.untyped` anywhere. +# +# @example +# +# # bad +# sig { params(my_argument: T.untyped).void } +# def foo(my_argument); end +# +# # good +# sig { params(my_argument: String).void } +# def foo(my_argument); end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb:20 +class RuboCop::Cop::Sorbet::ForbidTUntyped < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb:23 + def on_send(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_t_untyped.rb:21 + def t_untyped?(param0 = T.unsafe(nil)); end +end + +# This cop disallows use of `T.untyped` or `T.nilable(T.untyped)` +# as a prop type for `T::Struct`. +# +# @example +# +# # bad +# class SomeClass +# const :foo, T.untyped +# prop :bar, T.nilable(T.untyped) +# end +# +# # good +# class SomeClass +# const :foo, Integer +# prop :bar, T.nilable(String) +# end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:25 +class RuboCop::Cop::Sorbet::ForbidUntypedStructProps < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:48 + def on_class(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:40 + def subclass_of_t_struct?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:36 + def t_nilable_untyped(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:28 + def t_struct(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:32 + def t_untyped(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:44 + def untyped_props(param0); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb:26 +RuboCop::Cop::Sorbet::ForbidUntypedStructProps::MSG = T.let(T.unsafe(nil), String) + +# This cop makes the Sorbet typed sigil mandatory in all files. +# +# Options: +# +# * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false') +# * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one +# +# If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/has_sigil.rb:17 +class RuboCop::Cop::Sorbet::HasSigil < ::RuboCop::Cop::Sorbet::ValidSigil + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/has_sigil.rb:20 + def require_sigil_on_all_files?; end +end + +# This cop makes the Sorbet `ignore` sigil mandatory in all files. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb:10 +class RuboCop::Cop::Sorbet::IgnoreSigil < ::RuboCop::Cop::Sorbet::HasSigil + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/ignore_sigil.rb:11 + def minimum_strictness; end +end + +# This cop checks for the ordering of keyword arguments required by +# sorbet-runtime. The ordering requires that all keyword arguments +# are at the end of the parameters list, and all keyword arguments +# with a default value must be after those without default values. +# +# @example +# +# # bad +# sig { params(a: Integer, b: String).void } +# def foo(a: 1, b:); end +# +# # good +# sig { params(b: String, a: Integer).void } +# def foo(b:, a: 1); end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb:23 +class RuboCop::Cop::Sorbet::KeywordArgumentOrdering < ::RuboCop::Cop::Sorbet::SignatureCop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb:24 + def on_signature(node); end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb:34 + def check_order_for_kwoptargs(parameters); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb:8 +module RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb:15 + def on_assignment(value); end + + class << self + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb:9 + def prepended(base); end + end +end + +# This cop ensures one ancestor per requires_ancestor line +# rather than chaining them as a comma-separated list. +# +# @example +# +# # bad +# module SomeModule +# requires_ancestor Kernel, Minitest::Assertions +# end +# +# # good +# module SomeModule +# requires_ancestor Kernel +# requires_ancestor Minitest::Assertions +# end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:24 +class RuboCop::Cop::Sorbet::OneAncestorPerLine < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:35 + def abstract?(param0); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:51 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:31 + def more_than_one_ancestor(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:45 + def on_class(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:39 + def on_module(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:27 + def requires_ancestors(param0); end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:67 + def new_ra_line(indent_count); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:61 + def process_node(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/one_ancestor_per_line.rb:25 +RuboCop::Cop::Sorbet::OneAncestorPerLine::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:15 +class RuboCop::Cop::Sorbet::SignatureBuildOrder < ::RuboCop::Cop::Sorbet::SignatureCop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:54 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:34 + def on_signature(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:30 + def root_call(param0); end + + private + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:96 + def call_chain(sig_child_node); end + + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:92 + def can_autocorrect?; end + + # This method exists to reparse the current node with modern features enabled. + # Modern features include "index send" emitting, which is necessary to unparse + # "index sends" (i.e. `[]` calls) back to index accessors (i.e. as `foo[bar]``). + # Otherwise, we would get the unparsed node as `foo.[](bar)`. + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:83 + def node_reparsed_with_modern_features(node); end +end + +# Create a subclass of AST Builder that has modern features turned on +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:72 +class RuboCop::Cop::Sorbet::SignatureBuildOrder::ModernBuilder < ::RuboCop::AST::Builder; end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_build_order.rb:16 +RuboCop::Cop::Sorbet::SignatureBuildOrder::ORDER = T.let(T.unsafe(nil), Hash) + +# Abstract cop specific to Sorbet signatures +# +# You can subclass it to use the `on_signature` trigger and the `signature?` node matcher. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:11 +class RuboCop::Cop::Sorbet::SignatureCop < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:26 + def allowed_recv(recv); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:33 + def on_block(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:37 + def on_signature(_); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:14 + def signature?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:18 + def with_runtime?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/signatures/signature_cop.rb:22 + def without_runtime?(param0 = T.unsafe(nil)); end +end + +# This cop ensures empty class/module definitions in RBI files are +# done on a single line rather than being split across multiple lines. +# +# @example +# +# # bad +# module SomeModule +# end +# +# # good +# module SomeModule; end +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:17 +class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:28 + def autocorrect(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:24 + def on_class(node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:20 + def on_module(node); end + + protected + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:34 + def convert_newlines(source); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:38 + def process_node(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/rbi/single_line_rbi_class_module_definitions.rb:18 +RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::MSG = T.let(T.unsafe(nil), String) + +# This cop makes the Sorbet `strict` sigil mandatory in all files. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb:10 +class RuboCop::Cop::Sorbet::StrictSigil < ::RuboCop::Cop::Sorbet::HasSigil + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strict_sigil.rb:11 + def minimum_strictness; end +end + +# This cop makes the Sorbet `strong` sigil mandatory in all files. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb:10 +class RuboCop::Cop::Sorbet::StrongSigil < ::RuboCop::Cop::Sorbet::HasSigil + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/strong_sigil.rb:11 + def minimum_strictness; end +end + +# This cop makes the Sorbet `true` sigil mandatory in all files. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/true_sigil.rb:10 +class RuboCop::Cop::Sorbet::TrueSigil < ::RuboCop::Cop::Sorbet::HasSigil + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/true_sigil.rb:11 + def minimum_strictness; end +end + +# This cop ensures all constants used as `T.type_alias` are using CamelCase. +# +# @example +# +# # bad +# FOO_OR_BAR = T.type_alias { T.any(Foo, Bar) } +# +# # good +# FooOrBar = T.type_alias { T.any(Foo, Bar) } +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb:17 +class RuboCop::Cop::Sorbet::TypeAliasName < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb:20 + def casgn_type_alias?(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb:32 + def on_casgn(node); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/type_alias_name.rb:18 +RuboCop::Cop::Sorbet::TypeAliasName::MSG = T.let(T.unsafe(nil), String) + +# This cop checks that every Ruby file contains a valid Sorbet sigil. +# Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52 +# +# Options: +# +# * `RequireSigilOnAllFiles`: make offense if the Sorbet typed is not found in the file (default: false) +# * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false') +# * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one +# +# If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:18 +class RuboCop::Cop::Sorbet::ValidSigil < ::RuboCop::Cop::Cop + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:33 + def autocorrect(_node); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:21 + def investigate(processed_source); end + + protected + + # checks + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:68 + def check_sigil_present(sigil); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:125 + def check_strictness_level(sigil, strictness); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:103 + def check_strictness_not_empty(sigil, strictness); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:114 + def check_strictness_valid(sigil, strictness); end + + # extraction + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:56 + def extract_sigil(processed_source); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:62 + def extract_strictness(sigil); end + + # Default is `nil` + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:155 + def minimum_strictness; end + + # Default is `false` + # + # @return [Boolean] + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:144 + def require_sigil_on_all_files?; end + + # Default is `'false'` + # + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:149 + def suggested_strictness; end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:84 + def suggested_strictness_level(minimum_strictness, suggested_strictness); end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:52 +RuboCop::Cop::Sorbet::ValidSigil::SIGIL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb:51 +RuboCop::Cop::Sorbet::ValidSigil::STRICTNESS_LEVELS = T.let(T.unsafe(nil), Array) + +module RuboCop::Cop::Style; end + +class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb:3 +module RuboCop::Sorbet; end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb:11 +RuboCop::Sorbet::CONFIG = T.let(T.unsafe(nil), Hash) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb:10 +RuboCop::Sorbet::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb:7 +class RuboCop::Sorbet::Error < ::StandardError; end + +# Because RuboCop doesn't yet support plugins, we have to monkey patch in a +# bit of our configuration. +# +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet/inject.rb:9 +module RuboCop::Sorbet::Inject + class << self + # source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet/inject.rb:10 + def defaults!; end + end +end + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet.rb:9 +RuboCop::Sorbet::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname) + +# source://rubocop-sorbet-0.6.11/lib/rubocop/sorbet/version.rb:4 +RuboCop::Sorbet::VERSION = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token diff --git a/sorbet/rbi/gems/rubocop.rbi b/sorbet/rbi/gems/rubocop.rbi deleted file mode 100644 index fa8108d7..00000000 --- a/sorbet/rbi/gems/rubocop.rbi +++ /dev/null @@ -1,8900 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop/all/rubocop.rbi -# -# rubocop-1.31.2 - -module RuboCop -end -module RuboCop::Version - def self.document_version; end - def self.extension_versions(env); end - def self.feature_version(feature); end - def self.version(debug: nil, env: nil); end -end -module RuboCop::Ext -end -module RuboCop::Ext::RegexpNode - def assign_properties(*arg0); end - def each_capture(named: nil); end - def parsed_tree; end - def with_interpolations_blanked; end -end -class RuboCop::AST::RegexpNode < RuboCop::AST::Node - include RuboCop::Ext::RegexpNode -end -module RuboCop::Ext::RegexpParser -end -class RuboCop::Ext::RegexpParser::Map < Parser::Source::Map - def begin; end - def body; end - def end; end - def initialize(expression, body:, quantifier: nil, begin_l: nil, end_l: nil); end - def quantifier; end -end -module RuboCop::Ext::RegexpParser::Expression -end -module RuboCop::Ext::RegexpParser::Expression::Base - def build_location; end - def expression; end - def loc; end - def origin; end - def origin=(arg0); end -end -module RuboCop::Ext::RegexpParser::Expression::CharacterSet - def build_location; end -end -class Regexp::Expression::Base - include RuboCop::Ext::RegexpParser::Expression::Base -end -class Regexp::Expression::CharacterSet < Regexp::Expression::Subexpression - include RuboCop::Ext::RegexpParser::Expression::CharacterSet -end -class String - def blank?; end -end -module RuboCop::Ext::ProcessedSource - def comment_config; end - def disabled_line_ranges; end -end -class RuboCop::AST::ProcessedSource - include RuboCop::Ext::ProcessedSource -end -module RuboCop::PathUtil - def absolute?(path); end - def hidden_dir?(path); end - def hidden_file?(path); end - def hidden_file_in_not_hidden_dir?(pattern, path); end - def match_path?(pattern, path); end - def maybe_hidden_file?(path); end - def relative_path(path, base_dir = nil); end - def self.absolute?(path); end - def self.hidden_dir?(path); end - def self.hidden_file?(path); end - def self.hidden_file_in_not_hidden_dir?(pattern, path); end - def self.match_path?(pattern, path); end - def self.maybe_hidden_file?(path); end - def self.relative_path(path, base_dir = nil); end - def self.smart_path(path); end - def smart_path(path); end -end -module RuboCop::FileFinder - def find_file_upwards(filename, start_dir, stop_dir = nil); end - def find_last_file_upwards(filename, start_dir, stop_dir = nil); end - def self.root_level=(level); end - def self.root_level?(path, stop_dir); end - def traverse_files_upwards(filename, start_dir, stop_dir); end -end -module RuboCop::Platform - def self.windows?; end -end -module RuboCop::NameSimilarity - def find_similar_name(target_name, names); end - def find_similar_names(target_name, names); end - def self.find_similar_name(target_name, names); end - def self.find_similar_names(target_name, names); end -end -class RuboCop::StringInterpreter - def self.interpret(string); end - def self.interpret_hex(escape); end - def self.interpret_octal(escape); end - def self.interpret_string_escape(escape); end - def self.interpret_unicode(escape); end -end -class RuboCop::Error < StandardError -end -class RuboCop::ValidationError < RuboCop::Error -end -class RuboCop::ErrorWithAnalyzedFileLocation < RuboCop::Error - def cause; end - def column; end - def cop; end - def initialize(cause:, node:, cop:); end - def line; end - def message; end -end -class RuboCop::Warning < StandardError -end -module RuboCop::Util - def self.silence_warnings; end -end -module RuboCop::Cop -end -module RuboCop::Cop::Util - def add_parentheses(node, corrector); end - def args_begin(node); end - def args_end(node); end - def begins_its_line?(range); end - def comment_line?(line_source); end - def comment_lines?(node); end - def compatible_external_encoding_for?(src); end - def double_quotes_required?(string); end - def escape_string(string); end - def first_part_of_call_chain(node); end - def indent(node, offset: nil); end - def interpret_string_escapes(string); end - def line(node_or_range); end - def line_range(node); end - def needs_escaping?(string); end - def on_node(syms, sexp, excludes = nil, &block); end - def parentheses?(node); end - def same_line?(node1, node2); end - def self.add_parentheses(node, corrector); end - def self.args_begin(node); end - def self.args_end(node); end - def self.begins_its_line?(range); end - def self.comment_line?(line_source); end - def self.comment_lines?(node); end - def self.double_quotes_required?(string); end - def self.escape_string(string); end - def self.first_part_of_call_chain(node); end - def self.indent(node, offset: nil); end - def self.interpret_string_escapes(string); end - def self.line(node_or_range); end - def self.line_range(node); end - def self.needs_escaping?(string); end - def self.on_node(syms, sexp, excludes = nil, &block); end - def self.parentheses?(node); end - def self.same_line?(node1, node2); end - def self.to_string_literal(string); end - def self.to_supported_styles(enforced_style); end - def self.trim_string_interporation_escape_character(str); end - def to_string_literal(string); end - def to_supported_styles(enforced_style); end - def trim_string_interporation_escape_character(str); end - include RuboCop::PathUtil -end -class RuboCop::Cop::Offense - def <=>(other); end - def ==(other); end - def column; end - def column_length; end - def column_range; end - def cop_name; end - def correctable?; end - def corrected?; end - def corrected_with_todo?; end - def corrector; end - def disabled?; end - def eql?(other); end - def first_line; end - def hash; end - def highlighted_area; end - def initialize(severity, location, message, cop_name, status = nil, corrector = nil); end - def last_column; end - def last_line; end - def line; end - def location; end - def message; end - def real_column; end - def severity; end - def source_line; end - def status; end - def to_s; end - include Comparable -end -class RuboCop::Cop::Offense::PseudoSourceRange < Struct - def begin_pos; end - def begin_pos=(_); end - def column; end - def column=(_); end - def column_range; end - def end_pos; end - def end_pos=(_); end - def first_line; end - def last_column; end - def last_line; end - def length; end - def line; end - def line=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def size; end - def source_line; end - def source_line=(_); end -end -class RuboCop::Cop::MessageAnnotator - def annotate(message); end - def config; end - def cop_config; end - def cop_name; end - def debug?; end - def details; end - def display_cop_names?; end - def display_style_guide?; end - def extra_details?; end - def initialize(config, cop_name, cop_config, options); end - def options; end - def reference_urls; end - def self.style_guide_urls; end - def style_guide_base_url; end - def style_guide_url; end - def urls; end -end -module RuboCop::Cop::IgnoredNode - def ignore_node(node); end - def ignored_node?(node); end - def ignored_nodes; end - def part_of_ignored_node?(node); end -end -module RuboCop::Cop::AutocorrectLogic - def autocorrect?; end - def autocorrect_enabled?; end - def autocorrect_requested?; end - def autocorrect_with_disable_uncorrectable?; end - def correctable?; end - def disable_offense(range); end - def disable_offense_at_end_of_line(range, eol_comment); end - def disable_offense_before_and_after(range_by_lines); end - def disable_uncorrectable?; end - def max_line_length; end - def range_by_lines(range); end - def range_of_first_line(range); end - def safe_autocorrect?; end - def surrounding_heredoc(offense_range); end -end -module RuboCop::ExcludeLimit - def exclude_limit(parameter_name, method_name: nil); end - def transform(parameter_name); end -end -class RuboCop::Cop::Badge - def ==(other); end - def cop_name; end - def department; end - def eql?(other); end - def hash; end - def initialize(class_name_parts); end - def match?(other); end - def qualified?; end - def self.camel_case(name_part); end - def self.for(class_name); end - def self.parse(identifier); end - def to_s; end - def with_department(department); end -end -class RuboCop::Cop::AmbiguousCopName < RuboCop::Error - def initialize(name, origin, badges); end -end -class RuboCop::Cop::Registry - def ==(other); end - def clear_enrollment_queue; end - def contains_cop_matching?(names); end - def cops; end - def department?(name); end - def department_missing?(badge, name); end - def departments; end - def dismiss(cop); end - def each(&block); end - def enabled(config, only = nil, only_safe: nil); end - def enabled?(cop, config, only_safe); end - def enabled_pending_cop?(cop_cfg, config); end - def enlist(cop); end - def find_by_cop_name(cop_name); end - def freeze; end - def initialize(cops = nil, options = nil); end - def initialize_copy(reg); end - def length; end - def names; end - def names_for_department(department); end - def options; end - def print_warning(name, path); end - def qualified_cop_name(name, path, warn: nil); end - def qualify_badge(badge); end - def registered?(badge); end - def resolve_badge(given_badge, real_badge, source_path); end - def select(&block); end - def self.all; end - def self.global; end - def self.qualified_cop_name(name, origin); end - def self.reset!; end - def self.with_temporary_global(temp_global = nil); end - def sort!; end - def to_h; end - def unqualified_cop_names; end - def with(cops); end - def with_department(department); end - def without_department(department); end - include Enumerable -end -class RuboCop::Cop::Base - def active_support_extensions_enabled?; end - def add_global_offense(message = nil, severity: nil); end - def add_offense(node_or_range, message: nil, severity: nil, &block); end - def annotate(message); end - def apply_correction(corrector); end - def attempt_correction(range, corrector); end - def begin_investigation(processed_source); end - def callback_argument(range); end - def callbacks_needed; end - def complete_investigation; end - def config; end - def config_to_allow_offenses; end - def config_to_allow_offenses=(hash); end - def cop_config; end - def cop_name; end - def correct(range); end - def current_offense_locations; end - def currently_disabled_lines; end - def custom_severity; end - def default_severity; end - def disable_uncorrectable(range); end - def enabled_line?(line_number); end - def excluded_file?(file); end - def external_dependency_checksum; end - def file_name_matches_any?(file, parameter, default_result); end - def find_message(range, message); end - def find_severity(_range, severity); end - def initialize(config = nil, options = nil); end - def message(_range = nil); end - def name; end - def offenses; end - def on_investigation_end; end - def on_new_investigation; end - def on_other_file; end - def parse(source, path = nil); end - def processed_source; end - def range_from_node_or_range(node_or_range); end - def ready; end - def relevant_file?(file); end - def reset_investigation; end - def self.autocorrect_incompatible_with; end - def self.badge; end - def self.builtin?; end - def self.callbacks_needed; end - def self.cop_name; end - def self.department; end - def self.documentation_url; end - def self.exclude_from_registry; end - def self.inherited(subclass); end - def self.joining_forces; end - def self.lint?; end - def self.match?(given_names); end - def self.restrict_on_send; end - def self.support_autocorrect?; end - def self.support_multiple_source?; end - def target_rails_version; end - def target_ruby_version; end - def use_corrector(range, corrector); end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::AST::Sexp - extend RuboCop::ExcludeLimit - include RuboCop::AST::Sexp - include RuboCop::Cop::AutocorrectLogic - include RuboCop::Cop::IgnoredNode - include RuboCop::Cop::Util -end -class RuboCop::Cop::Base::InvestigationReport < Struct - def cop; end - def cop=(_); end - def corrector; end - def corrector=(_); end - def offenses; end - def offenses=(_); end - def processed_source; end - def processed_source=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -module RuboCop::Cop::Legacy -end -class RuboCop::Cop::Legacy::CorrectionsProxy - def <<(callable); end - def concat(corrections); end - def corrector; end - def empty?; end - def initialize(corrector); end - def suppress_clobbering; end -end -class RuboCop::Cop::Cop < RuboCop::Cop::Base - def add_offense(node_or_range, location: nil, message: nil, severity: nil, &block); end - def apply_correction(corrector); end - def begin_investigation(processed_source); end - def callback_argument(_range); end - def correction_lambda; end - def corrections; end - def dedup_on_node(node); end - def emulate_v0_callsequence(corrector); end - def find_location(node, loc); end - def offenses; end - def on_investigation_end; end - def on_new_investigation; end - def self.all; end - def self.joining_forces; end - def self.qualified_cop_name(name, origin); end - def self.registry; end - def self.support_autocorrect?; end - def support_autocorrect?; end - def suppress_clobbering; end -end -class RuboCop::Cop::Cop::Correction < Struct - def call(corrector); end - def cop; end - def cop=(_); end - def lambda; end - def lambda=(_); end - def node; end - def node=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RuboCop::Cop::Commissioner - def build_callbacks(cops); end - def errors; end - def initialize(cops, forces = nil, options = nil); end - def initialize_callbacks; end - def investigate(processed_source); end - def invoke(callback, cops, *args); end - def on___ENCODING__(node); end - def on___FILE__(node); end - def on___LINE__(node); end - def on_alias(node); end - def on_and(node); end - def on_and_asgn(node); end - def on_arg(node); end - def on_arg_expr(node); end - def on_args(node); end - def on_array(node); end - def on_array_pattern(node); end - def on_array_pattern_with_tail(node); end - def on_back_ref(node); end - def on_begin(node); end - def on_block(node); end - def on_block_pass(node); end - def on_blockarg(node); end - def on_break(node); end - def on_case(node); end - def on_case_match(node); end - def on_casgn(node); end - def on_cbase(node); end - def on_class(node); end - def on_complex(node); end - def on_const(node); end - def on_const_pattern(node); end - def on_csend(node); end - def on_cvar(node); end - def on_cvasgn(node); end - def on_def(node); end - def on_defined?(node); end - def on_defs(node); end - def on_dstr(node); end - def on_dsym(node); end - def on_eflipflop(node); end - def on_empty_else(node); end - def on_ensure(node); end - def on_erange(node); end - def on_false(node); end - def on_find_pattern(node); end - def on_float(node); end - def on_for(node); end - def on_forward_arg(node); end - def on_forward_args(node); end - def on_forwarded_args(node); end - def on_gvar(node); end - def on_gvasgn(node); end - def on_hash(node); end - def on_hash_pattern(node); end - def on_if(node); end - def on_if_guard(node); end - def on_iflipflop(node); end - def on_in_match(node); end - def on_in_pattern(node); end - def on_index(node); end - def on_indexasgn(node); end - def on_int(node); end - def on_irange(node); end - def on_ivar(node); end - def on_ivasgn(node); end - def on_kwarg(node); end - def on_kwargs(node); end - def on_kwbegin(node); end - def on_kwnilarg(node); end - def on_kwoptarg(node); end - def on_kwrestarg(node); end - def on_kwsplat(node); end - def on_lambda(node); end - def on_lvar(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_match_alt(node); end - def on_match_as(node); end - def on_match_current_line(node); end - def on_match_nil_pattern(node); end - def on_match_pattern(node); end - def on_match_pattern_p(node); end - def on_match_rest(node); end - def on_match_var(node); end - def on_match_with_lvasgn(node); end - def on_match_with_trailing_comma(node); end - def on_mlhs(node); end - def on_module(node); end - def on_next(node); end - def on_nil(node); end - def on_not(node); end - def on_nth_ref(node); end - def on_numblock(node); end - def on_op_asgn(node); end - def on_optarg(node); end - def on_or(node); end - def on_or_asgn(node); end - def on_pair(node); end - def on_pin(node); end - def on_postexe(node); end - def on_preexe(node); end - def on_procarg0(node); end - def on_rational(node); end - def on_redo(node); end - def on_regexp(node); end - def on_regopt(node); end - def on_resbody(node); end - def on_rescue(node); end - def on_restarg(node); end - def on_retry(node); end - def on_return(node); end - def on_sclass(node); end - def on_self(node); end - def on_send(node); end - def on_shadowarg(node); end - def on_splat(node); end - def on_str(node); end - def on_super(node); end - def on_sym(node); end - def on_true(node); end - def on_undef(node); end - def on_unless_guard(node); end - def on_until(node); end - def on_until_post(node); end - def on_when(node); end - def on_while(node); end - def on_while_post(node); end - def on_xstr(node); end - def on_yield(node); end - def on_zsuper(node); end - def reset; end - def restrict_callbacks(callbacks); end - def restricted_map(callbacks); end - def trigger_responding_cops(callback, node); end - def trigger_restricted_cops(event, node); end - def with_cop_error_handling(cop, node = nil); end - include RuboCop::AST::Traversal -end -class RuboCop::Cop::Commissioner::InvestigationReport < Struct - def cop_reports; end - def cop_reports=(_); end - def cops; end - def correctors; end - def errors; end - def errors=(_); end - def merge(investigation); end - def offenses; end - def offenses_per_cop; end - def processed_source; end - def processed_source=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -module RuboCop::Cop::Documentation - def base_url_for(cop_class, config); end - def default_base_url; end - def department_to_basename(department); end - def self.base_url_for(cop_class, config); end - def self.default_base_url; end - def self.department_to_basename(department); end - def self.url_for(cop_class, config = nil); end - def url_for(cop_class, config = nil); end -end -class RuboCop::Cop::Corrector < Parser::Source::TreeRewriter - def check_range_validity(node_or_range); end - def initialize(source); end - def remove_leading(node_or_range, size); end - def remove_preceding(node_or_range, size); end - def remove_trailing(node_or_range, size); end - def rewrite; end - def self.source_buffer(source); end - def to_range(node_or_range); end - def validate_buffer(buffer); end -end -class RuboCop::Cop::Force - def cops; end - def initialize(cops); end - def investigate(_processed_source); end - def name; end - def run_hook(method_name, *args); end - def self.all; end - def self.force_name; end - def self.inherited(subclass); end -end -class RuboCop::Cop::Severity - def <=>(other); end - def ==(other); end - def code; end - def hash; end - def initialize(name_or_code); end - def level; end - def name; end - def self.name_from_code(code); end - def to_s; end - include Comparable -end -class RuboCop::Cop::Generator - def badge; end - def generate(template); end - def generated_source; end - def generated_spec; end - def initialize(name, output: nil); end - def inject_config(config_file_path: nil, version_added: nil); end - def inject_require(root_file_path: nil); end - def output; end - def snake_case(camel_case_string); end - def source_path; end - def spec_path; end - def todo; end - def write_source; end - def write_spec; end - def write_unless_file_exists(path, contents); end -end -class RuboCop::Cop::Generator::ConfigurationInjector - def badge; end - def configuration_entries; end - def configuration_file_path; end - def cop_name_line?(yaml); end - def find_target_line; end - def initialize(configuration_file_path:, badge:, version_added: nil); end - def inject; end - def new_configuration_entry; end - def output; end - def version_added; end -end -class RuboCop::Cop::Generator::RequireFileInjector - def initialize(source_path:, root_file_path:, output: nil); end - def inject; end - def injectable_require_directive; end - def output; end - def require_entries; end - def require_exists?; end - def require_path; end - def require_path_fragments(require_directove); end - def root_file_path; end - def source_path; end - def target_line; end - def updated_directives; end -end -class RuboCop::Cop::VariableForce < RuboCop::Cop::Force - def after_declaring_variable(arg); end - def after_entering_scope(arg); end - def after_leaving_scope(arg); end - def before_declaring_variable(arg); end - def before_entering_scope(arg); end - def before_leaving_scope(arg); end - def descendant_reference(node); end - def each_descendant_reference(loop_node); end - def find_variables_in_loop(loop_node); end - def inspect_variables_in_scope(scope_node); end - def investigate(processed_source); end - def mark_assignments_as_referenced_in_loop(node); end - def node_handler_method_name(node); end - def process_children(origin_node); end - def process_loop(node); end - def process_node(node); end - def process_regexp_named_captures(node); end - def process_rescue(node); end - def process_scope(node); end - def process_send(node); end - def process_variable_assignment(node); end - def process_variable_declaration(node); end - def process_variable_multiple_assignment(node); end - def process_variable_operator_assignment(node); end - def process_variable_referencing(node); end - def process_zero_arity_super(node); end - def regexp_captured_names(node); end - def scanned_node?(node); end - def scanned_nodes; end - def skip_children!; end - def twisted_nodes(node); end - def variable_table; end -end -class RuboCop::Cop::VariableForce::VariableReference < Struct - def assignment?; end - def name; end - def name=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RuboCop::Cop::VariableForce::AssignmentReference < Struct - def assignment?; end - def node; end - def node=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -module RuboCop::Cop::VariableForce::Branch - def self.of(target_node, scope: nil); end -end -class RuboCop::Cop::VariableForce::Branch::Base < Struct - def ==(other); end - def always_run?; end - def branched?; end - def child_node; end - def child_node=(_); end - def control_node; end - def each_ancestor(include_self: nil, &block); end - def eql?(other); end - def exclusive_with?(other); end - def hash; end - def may_jump_to_other_branch?; end - def may_run_incompletely?; end - def parent; end - def scan_ancestors; end - def scope; end - def scope=(_); end - def self.[](*arg0); end - def self.classes; end - def self.define_predicate(name, child_index: nil); end - def self.inherited(subclass); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def self.type; end -end -module RuboCop::Cop::VariableForce::Branch::SimpleConditional - def always_run?; end - def conditional_clause?; end -end -class RuboCop::Cop::VariableForce::Branch::If < RuboCop::Cop::VariableForce::Branch::Base - def conditional_clause?; end - def falsey_body?; end - def truthy_body?; end - include RuboCop::Cop::VariableForce::Branch::SimpleConditional -end -class RuboCop::Cop::VariableForce::Branch::While < RuboCop::Cop::VariableForce::Branch::Base - def conditional_clause?; end - def loop_body?; end - include RuboCop::Cop::VariableForce::Branch::SimpleConditional -end -class RuboCop::Cop::VariableForce::Branch::Until < RuboCop::Cop::VariableForce::Branch::Base - def conditional_clause?; end - def loop_body?; end - include RuboCop::Cop::VariableForce::Branch::SimpleConditional -end -class RuboCop::Cop::VariableForce::Branch::WhilePost < RuboCop::Cop::VariableForce::Branch::Base - def conditional_clause?; end - def loop_body?; end - include RuboCop::Cop::VariableForce::Branch::SimpleConditional -end -class RuboCop::Cop::VariableForce::Branch::UntilPost < RuboCop::Cop::VariableForce::Branch::Base - def conditional_clause?; end - def loop_body?; end - include RuboCop::Cop::VariableForce::Branch::SimpleConditional -end -class RuboCop::Cop::VariableForce::Branch::Case < RuboCop::Cop::VariableForce::Branch::Base - def always_run?; end - def else_body?; end - def target?; end - def when_clause?; end -end -class RuboCop::Cop::VariableForce::Branch::CaseMatch < RuboCop::Cop::VariableForce::Branch::Base - def always_run?; end - def else_body?; end - def in_pattern?; end - def target?; end -end -class RuboCop::Cop::VariableForce::Branch::For < RuboCop::Cop::VariableForce::Branch::Base - def always_run?; end - def collection?; end - def element?; end - def loop_body?; end -end -module RuboCop::Cop::VariableForce::Branch::LogicalOperator - def always_run?; end -end -class RuboCop::Cop::VariableForce::Branch::And < RuboCop::Cop::VariableForce::Branch::Base - def left_body?; end - def right_body?; end - include RuboCop::Cop::VariableForce::Branch::LogicalOperator -end -class RuboCop::Cop::VariableForce::Branch::Or < RuboCop::Cop::VariableForce::Branch::Base - def left_body?; end - def right_body?; end - include RuboCop::Cop::VariableForce::Branch::LogicalOperator -end -module RuboCop::Cop::VariableForce::Branch::ExceptionHandler - def may_jump_to_other_branch?; end - def may_run_incompletely?; end -end -class RuboCop::Cop::VariableForce::Branch::Rescue < RuboCop::Cop::VariableForce::Branch::Base - def always_run?; end - def else_body?; end - def main_body?; end - def rescue_clause?; end - include RuboCop::Cop::VariableForce::Branch::ExceptionHandler -end -class RuboCop::Cop::VariableForce::Branch::Ensure < RuboCop::Cop::VariableForce::Branch::Base - def always_run?; end - def ensure_body?; end - def main_body?; end - include RuboCop::Cop::VariableForce::Branch::ExceptionHandler -end -module RuboCop::Cop::VariableForce::Branchable - def branch; end - def run_exclusively_with?(other); end -end -class RuboCop::Cop::VariableForce::Variable - def argument?; end - def assign(node); end - def assignments; end - def block_argument?; end - def capture_with_block!; end - def captured_by_block; end - def captured_by_block?; end - def declaration_node; end - def explicit_block_local_variable?; end - def in_modifier_if?(assignment); end - def initialize(name, declaration_node, scope); end - def keyword_argument?; end - def method_argument?; end - def name; end - def reference!(node); end - def referenced?; end - def references; end - def scope; end - def should_be_unused?; end - def used?; end -end -class RuboCop::Cop::VariableForce::Assignment - def initialize(node, variable); end - def meta_assignment_node; end - def multiple_assignment?; end - def multiple_assignment_node; end - def name; end - def node; end - def operator; end - def operator_assignment?; end - def operator_assignment_node; end - def reference!(node); end - def referenced; end - def referenced?; end - def references; end - def regexp_named_capture?; end - def scope; end - def used?; end - def variable; end - include RuboCop::Cop::VariableForce::Branchable -end -class RuboCop::Cop::VariableForce::Reference - def explicit?; end - def initialize(node, scope); end - def node; end - def scope; end - include RuboCop::Cop::VariableForce::Branchable -end -class RuboCop::Cop::VariableForce::Scope - def ==(other); end - def ancestor_node?(target_node); end - def belong_to_inner_scope?(target_node); end - def belong_to_outer_scope?(target_node); end - def body_node; end - def each_node(&block); end - def include?(target_node); end - def initialize(node); end - def naked_top_level; end - def naked_top_level?; end - def name; end - def node; end - def scan_node(node, &block); end - def variables; end -end -class RuboCop::Cop::VariableForce::VariableTable - def accessible_variables; end - def assign_to_variable(name, node); end - def current_scope; end - def current_scope_level; end - def declare_variable(name, node); end - def find_variable(name); end - def initialize(hook_receiver = nil); end - def invoke_hook(hook_name, *args); end - def mark_variable_as_captured_by_block_if_so(variable); end - def pop_scope; end - def push_scope(scope_node); end - def reference_variable(name, node); end - def scope_stack; end - def variable_exist?(name); end -end -module RuboCop::Cop::ArrayMinSize - def array_style_detected(style, ary_size); end - def below_array_length?(node); end - def largest_brackets_size(style, ary_size); end - def min_size_config; end - def smallest_percent_size(style, ary_size); end -end -module RuboCop::Cop::ArraySyntax - def bracketed_array_of?(element_type, node); end -end -module RuboCop::Cop::Alignment - def check_alignment(items, base_column = nil); end - def column_delta; end - def configured_indentation_width; end - def display_column(range); end - def each_bad_alignment(items, base_column); end - def end_of_line_comment(line); end - def indentation(node); end - def offset(node); end - def register_offense(offense_node, message_node); end - def within?(inner, outer); end -end -module RuboCop::Cop::AllowedIdentifiers - def allowed_identifier?(name); end - def allowed_identifiers; end -end -module RuboCop::Cop::AllowedMethods - def allowed_method?(name); end - def allowed_methods; end -end -module RuboCop::Cop::AllowedPattern - def allowed_line?(line); end - def allowed_patterns; end - def ignored_line?(line); end - def matches_allowed_pattern?(line); end - def matches_ignored_pattern?(line); end -end -module RuboCop::Cop::AutoCorrector - def support_autocorrect?; end -end -module RuboCop::Cop::CheckAssignment - def extract_rhs(node); end - def on_and_asgn(node); end - def on_casgn(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_op_asgn(node); end - def on_or_asgn(node); end - def on_send(node); end - def self.extract_rhs(node); end -end -module RuboCop::Cop::CheckLineBreakable - def all_on_same_line?(nodes); end - def already_on_multiple_lines?(node); end - def breakable_collection?(node, elements); end - def children_could_be_broken_up?(children); end - def contained_by_breakable_collection_on_same_line?(node); end - def contained_by_multiline_collection_that_could_be_broken_up?(node); end - def extract_breakable_node(node, max); end - def extract_breakable_node_from_elements(node, elements, max); end - def extract_first_element_over_column_limit(node, elements, max); end - def first_argument_is_heredoc?(node); end - def process_args(args); end - def safe_to_ignore?(node); end - def shift_elements_for_heredoc_arg(node, elements, index); end - def within_column_limit?(element, max, line); end -end -module RuboCop::Cop::ConfigurableMax - def max=(value); end - def max_parameter_name; end -end -module RuboCop::Cop::CodeLength - def build_code_length_calculator(node); end - def check_code_length(node); end - def count_as_one; end - def count_comments?; end - def irrelevant_line(source_line); end - def max=(value); end - def max_length; end - def message(length, max_length); end - extend RuboCop::ExcludeLimit -end -module RuboCop::Cop::ConfigurableEnforcedStyle - def alternative_style; end - def alternative_styles; end - def ambiguous_style_detected(*possibilities); end - def conflicting_styles_detected; end - def correct_style_detected; end - def detected_style; end - def detected_style=(style); end - def no_acceptable_style!; end - def no_acceptable_style?; end - def opposite_style_detected; end - def style; end - def style_configured?; end - def style_detected(detected); end - def style_parameter_name; end - def supported_styles; end - def unexpected_style_detected(unexpected); end - def unrecognized_style_detected; end -end -module RuboCop::Cop::ConfigurableFormatting - def check_name(node, name, name_range); end - def class_emitter_method?(node, name); end - def report_opposing_styles(node, name); end - def valid_name?(node, name, given_style = nil); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -module RuboCop::Cop::ConfigurableNaming - include RuboCop::Cop::ConfigurableFormatting -end -module RuboCop::Cop::ConfigurableNumbering - include RuboCop::Cop::ConfigurableFormatting -end -module RuboCop::Cop::DocumentationComment - def annotation_keywords; end - def documentation_comment?(node); end - def interpreter_directive_comment?(comment); end - def precede?(node1, node2); end - def preceding_comment?(node1, node2); end - def preceding_lines(node); end - def rubocop_directive_comment?(comment); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::Duplication - def consecutive_duplicates(collection); end - def duplicates(collection); end - def duplicates?(collection); end - def grouped_duplicates(collection); end -end -module RuboCop::Cop::RangeHelp - def column_offset_between(base_range, range); end - def contents_range(node); end - def directions(side); end - def effective_column(range); end - def final_pos(src, pos, increment, continuations, newlines, whitespace); end - def move_pos(src, pos, step, condition, regexp); end - def move_pos_str(src, pos, step, condition, needle); end - def range_between(start_pos, end_pos); end - def range_by_whole_lines(range, include_final_newline: nil); end - def range_with_surrounding_comma(range, side = nil); end - def range_with_surrounding_space(range_positional = nil, range: nil, side: nil, newlines: nil, whitespace: nil, continuations: nil); end - def source_range(source_buffer, line_number, column, length = nil); end -end -module RuboCop::Cop::RangeHelp::NOT_GIVEN -end -class RuboCop::Cop::AnnotationComment - def annotation?; end - def bounds; end - def colon; end - def comment; end - def correct?(colon:); end - def initialize(comment, keywords); end - def just_keyword_of_sentence?; end - def keyword; end - def keyword_appearance?; end - def keywords; end - def margin; end - def note; end - def space; end - def split_comment(comment); end - extend Forwardable -end -module RuboCop::Cop::Layout -end -module RuboCop::Cop::Layout::EmptyLinesAroundBody - def check(node, body, adjusted_first_line: nil); end - def check_beginning(style, first_line); end - def check_both(style, first_line, last_line); end - def check_deferred_empty_line(body); end - def check_empty_lines_except_namespace(body, first_line, last_line); end - def check_empty_lines_special(body, first_line, last_line); end - def check_ending(style, last_line); end - def check_line(style, line, msg); end - def check_source(style, line_no, desc); end - def constant_definition?(param0 = nil); end - def deferred_message(node); end - def empty_line_required?(param0 = nil); end - def first_child_requires_empty_line?(body); end - def first_empty_line_required_child(body); end - def message(type, desc); end - def namespace?(body, with_one_child: nil); end - def previous_line_ignoring_comments(send_line); end - def valid_body_style?(body); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::EmptyParameter - def check(node); end - def empty_arguments?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::EndKeywordAlignment - def accept_end_kw_alignment?(end_loc); end - def add_offense_for_misalignment(node, align_with); end - def check_end_kw_alignment(node, align_ranges); end - def check_end_kw_in_node(node); end - def line_break_before_keyword?(whole_expression, rhs); end - def matching_ranges(end_loc, align_ranges); end - def start_line_range(node); end - def style_parameter_name; end - def variable_alignment?(whole_expression, rhs, end_alignment_style); end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::EnforceSuperclass - def on_class(node); end - def on_send(node); end - def self.included(base); end -end -module RuboCop::Cop::FirstElementLineBreak - def check_children_line_break(node, children, start = nil); end - def check_method_line_break(node, children); end - def first_by_line(nodes); end - def last_by_line(nodes); end - def method_uses_parens?(node, limit); end -end -module RuboCop::Cop::FrozenStringLiteral - def frozen_heredoc?(node); end - def frozen_string_literal?(node); end - def frozen_string_literal_comment_exists?; end - def frozen_string_literal_specified?; end - def frozen_string_literals_disabled?; end - def frozen_string_literals_enabled?; end - def leading_comment_lines; end - def self.frozen_string_literal_comment_exists?; end - def uninterpolated_string?(node); end -end -module RuboCop::Cop::GemDeclaration - def gem_declaration?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::GemspecHelp - def gem_specification(param0); end - def gem_specification?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::HashAlignmentStyles -end -class RuboCop::Cop::HashAlignmentStyles::KeyAlignment - def checkable_layout?(_node); end - def deltas(first_pair, current_pair); end - def deltas_for_first_pair(first_pair, _node); end - def separator_delta(pair); end - def value_delta(pair); end -end -module RuboCop::Cop::HashAlignmentStyles::ValueAlignment - def checkable_layout?(node); end - def deltas(first_pair, current_pair); end - def separator_delta(first_pair, current_pair, key_delta); end -end -class RuboCop::Cop::HashAlignmentStyles::TableAlignment - def deltas_for_first_pair(first_pair, node); end - def hash_rocket_delta(first_pair, current_pair); end - def initialize; end - def key_delta(first_pair, current_pair); end - def max_key_width; end - def max_key_width=(arg0); end - def value_delta(first_pair, current_pair); end - include RuboCop::Cop::HashAlignmentStyles::ValueAlignment -end -class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment - def deltas_for_first_pair(*_nodes); end - def hash_rocket_delta(first_pair, current_pair); end - def key_delta(first_pair, current_pair); end - def value_delta(first_pair, current_pair); end - include RuboCop::Cop::HashAlignmentStyles::ValueAlignment -end -class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment - def deltas(first_pair, current_pair); end -end -module RuboCop::Cop::HashTransformMethod - def array_receiver?(param0 = nil); end - def execute_correction(corrector, node, correction); end - def extract_captures(_match); end - def handle_possible_offense(node, match, match_desc); end - def new_method_name; end - def on_bad_each_with_object(_node); end - def on_bad_hash_brackets_map(_node); end - def on_bad_map_to_h(_node); end - def on_bad_to_h(_node); end - def on_block(node); end - def on_csend(node); end - def on_send(node); end - def prepare_correction(node); end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::HashTransformMethod::Captures < Struct - def noop_transformation?; end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def transformation_uses_both_args?; end - def transformed_argname; end - def transformed_argname=(_); end - def transforming_body_expr; end - def transforming_body_expr=(_); end - def unchanged_body_expr; end - def unchanged_body_expr=(_); end -end -class RuboCop::Cop::HashTransformMethod::Autocorrection < Struct - def block_node; end - def block_node=(_); end - def leading; end - def leading=(_); end - def match; end - def match=(_); end - def self.[](*arg0); end - def self.from_each_with_object(node, match); end - def self.from_hash_brackets_map(node, match); end - def self.from_map_to_h(node, match); end - def self.from_to_h(node, match); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def set_new_arg_name(transformed_argname, corrector); end - def set_new_body_expression(transforming_body_expr, corrector); end - def set_new_method_name(new_method_name, corrector); end - def strip_prefix_and_suffix(node, corrector); end - def trailing; end - def trailing=(_); end -end -module RuboCop::Cop::IgnoredMethods - def deprecated_key; end - def ignored_method?(name); end - def ignored_methods; end - def self.included(base); end -end -module RuboCop::Cop::IgnoredMethods::Config - def deprecated_key; end - def deprecated_key=(arg0); end - def ignored_methods(**config); end -end -module RuboCop::Cop::IntegerNode - def integer_part(node); end -end -module RuboCop::Cop::Interpolation - def on_dstr(node); end - def on_dsym(node); end - def on_node_with_interpolations(node); end - def on_regexp(node); end - def on_xstr(node); end -end -module RuboCop::Cop::LineLengthHelp - def allow_uri?; end - def allowed_uri_position?(line, uri_range); end - def directive_on_source_line?(line_index); end - def extend_uri_end_position(line, end_position); end - def find_excessive_uri_range(line); end - def ignore_cop_directives?; end - def indentation_difference(line); end - def line_length(line); end - def line_length_without_directive(line); end - def match_uris(string); end - def tab_indentation_width; end - def uri_regexp; end - def valid_uri?(uri_ish_string); end -end -module RuboCop::Cop::MatchRange - def each_match_range(range, regex); end - def match_range(range, match); end - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::Metrics -end -module RuboCop::Cop::Metrics::Utils -end -module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount - def discount_for_repeated_csend?(csend_node); end - def reset_on_lvasgn(node); end - def reset_repeated_csend; end -end -module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount - def attribute_call?(param0 = nil); end - def calculate_node(node); end - def discount_repeated_attribute?(send_node); end - def discount_repeated_attributes?; end - def evaluate_branch_nodes(node); end - def find_attributes(node, &block); end - def initialize(node, discount_repeated_attributes: nil); end - def root_node?(param0 = nil); end - def setter_to_getter(node); end - def update_repeated_attribute(node); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::AST::Sexp -end -module RuboCop::Cop::HashShorthandSyntax - def enforced_shorthand_syntax; end - def ignore_hash_shorthand_syntax?(pair_node); end - def on_pair(node); end - def register_offense(node, message, replacement); end - def require_hash_value?(hash_key_source, node); end - def require_hash_value_for_around_hash_literal?(node); end - def use_element_of_hash_literal_as_receiver?(ancestor, parent); end - def use_modifier_form_without_parenthesized_method_call?(ancestor); end - def without_parentheses_call_expr_follows?(ancestor); end -end -module RuboCop::Cop::MethodComplexity - def check_complexity(node, method_name); end - def complexity(body); end - def define_method?(param0 = nil); end - def max=(value); end - def on_block(node); end - def on_def(node); end - def on_defs(node); end - def self.included(base); end - extend RuboCop::AST::NodePattern::Macros - extend RuboCop::Cop::IgnoredMethods::Config - extend RuboCop::ExcludeLimit - include RuboCop::Cop::IgnoredMethods - include RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount -end -module RuboCop::Cop::MethodPreference - def default_cop_config; end - def preferred_method(method); end - def preferred_methods; end -end -module RuboCop::Cop::MinBodyLength - def min_body_length; end - def min_body_length?(node); end -end -module RuboCop::Cop::MultilineElementIndentation - def check_expected_style(styles); end - def check_first(first, left_brace, left_parenthesis, offset); end - def detected_styles(actual_column, offset, left_parenthesis, left_brace); end - def detected_styles_for_column(column, left_parenthesis, left_brace); end - def each_argument_node(node, type); end - def hash_pair_where_value_beginning_with(left_brace, first); end - def incorrect_style_detected(styles, first, base_column_type); end - def indent_base(left_brace, first, left_parenthesis); end - def key_and_value_begin_on_same_line?(pair); end - def right_sibling_begins_on_subsequent_line?(pair); end -end -module RuboCop::Cop::MultilineElementLineBreaks - def all_on_same_line?(nodes); end - def check_line_breaks(_node, children); end -end -module RuboCop::Cop::MultilineExpressionIndentation - def argument_in_method_call(node, kind); end - def assignment_rhs(node); end - def check(range, node, lhs, rhs); end - def correct_indentation(node); end - def disqualified_rhs?(candidate, ancestor); end - def grouped_expression?(node); end - def incorrect_style_detected(range, node, lhs, rhs); end - def indentation(node); end - def indented_keyword_expression(node); end - def inside_arg_list_parentheses?(node, ancestor); end - def keyword_message_tail(node); end - def kw_node_with_special_indentation(node); end - def left_hand_side(lhs); end - def not_for_this_cop?(node); end - def on_send(node); end - def operation_description(node, rhs); end - def part_of_assignment_rhs(node, candidate); end - def part_of_block_body?(candidate, block_node); end - def postfix_conditional?(node); end - def valid_method_rhs_candidate?(candidate, node); end - def valid_rhs?(candidate, ancestor); end - def valid_rhs_candidate?(candidate, node); end - def within_node?(inner, outer); end -end -module RuboCop::Cop::MultilineLiteralBraceLayout - def check(node); end - def check_brace_layout(node); end - def check_new_line(node); end - def check_same_line(node); end - def check_symmetrical(node); end - def children(node); end - def closing_brace_on_same_line?(node); end - def empty_literal?(node); end - def ignored_literal?(node); end - def implicit_literal?(node); end - def last_line_heredoc?(node, parent = nil); end - def new_line_needed_before_closing_brace?(node); end - def opening_brace_on_same_line?(node); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -module RuboCop::Cop::NegativeConditional - def check_negative_conditional(node, message:, &block); end - def empty_condition?(param0 = nil); end - def single_negative?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::Heredoc - def delimiter_string(node); end - def heredoc_type(node); end - def indent_level(str); end - def on_dstr(node); end - def on_heredoc(_node); end - def on_str(node); end - def on_xstr(node); end -end -module RuboCop::Cop::NilMethods - def nil_methods; end - def other_stdlib_methods; end - include RuboCop::Cop::AllowedMethods -end -module RuboCop::Cop::OnNormalIfUnless - def on_if(node); end -end -module RuboCop::Cop::OrderedGemNode - def case_insensitive_out_of_order?(string_a, string_b); end - def consecutive_lines(previous, current); end - def find_gem_name(gem_node); end - def gem_canonical_name(name); end - def gem_name(declaration_node); end - def get_source_range(node, comments_as_separators); end - def register_offense(previous, current); end - def treat_comments_as_separators; end -end -module RuboCop::Cop::Parentheses - def parens_required?(node); end -end -module RuboCop::Cop::PercentArray - def allowed_bracket_array?(node); end - def check_bracketed_array(node, literal_prefix); end - def check_percent_array(node); end - def comments_in_array?(node); end - def invalid_percent_array_contents?(_node); end - def invalid_percent_array_context?(node); end -end -module RuboCop::Cop::PercentLiteral - def begin_source(node); end - def percent_literal?(node); end - def process(node, *types); end - def type(node); end - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::PrecedingFollowingAlignment - def aligned_assignment?(range, line); end - def aligned_char?(range, line); end - def aligned_comment_lines; end - def aligned_identical?(range, line); end - def aligned_operator?(range, line); end - def aligned_token?(range, line); end - def aligned_with_adjacent_line?(range, predicate); end - def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate); end - def aligned_with_any_line_range?(line_ranges, range, &predicate); end - def aligned_with_append_operator?(range, line); end - def aligned_with_assignment(token, line_range); end - def aligned_with_line?(line_nos, range, indent = nil); end - def aligned_with_operator?(range); end - def aligned_with_preceding_assignment(token); end - def aligned_with_something?(range); end - def aligned_with_subsequent_assignment(token); end - def aligned_words?(range, line); end - def allow_for_alignment?; end - def assignment_lines; end - def assignment_tokens; end - def relevant_assignment_lines(line_range); end - def remove_optarg_equals(asgn_tokens, processed_source); end -end -class RuboCop::Cop::PreferredDelimiters - def config; end - def delimiters; end - def ensure_valid_preferred_delimiters; end - def initialize(type, config, preferred_delimiters); end - def preferred_delimiters; end - def preferred_delimiters_config; end - def type; end -end -module RuboCop::Cop::RationalLiteral - def rational_literal?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::RequireLibrary - def ensure_required(corrector, node, library_name); end - def on_new_investigation; end - def on_send(node); end - def remove_subsequent_requires(corrector, node, library_name); end - def require_any_library?(param0 = nil); end - def require_library_name?(param0 = nil, param1); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::RescueNode - def on_new_investigation; end - def rescue_modifier?(node); end - def rescued_exceptions(resbody); end -end -module RuboCop::Cop::SafeAssignment - def empty_condition?(param0 = nil); end - def safe_assignment?(param0 = nil); end - def safe_assignment_allowed?; end - def setter_method?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::SpaceAfterPunctuation - def allowed_type?(token); end - def each_missing_space(tokens); end - def offset; end - def on_new_investigation; end - def space_forbidden_before_rcurly?; end - def space_missing?(token1, token2); end - def space_required_before?(token); end -end -module RuboCop::Cop::SpaceBeforePunctuation - def each_missing_space(tokens); end - def on_new_investigation; end - def space_missing?(token1, token2); end - def space_required_after?(token); end - def space_required_after_lcurly?; end - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::SurroundingSpace - def empty_brackets?(left_bracket_token, right_bracket_token); end - def empty_offense(node, range, message, command); end - def empty_offenses(node, left, right, message); end - def extra_space?(token, side); end - def no_space_between?(left_bracket_token, right_bracket_token); end - def no_space_offenses(node, left_token, right_token, message, start_ok: nil, end_ok: nil); end - def offending_empty_no_space?(config, left_token, right_token); end - def offending_empty_space?(config, left_token, right_token); end - def on_new_investigation; end - def reposition(src, pos, step); end - def side_space_range(range:, side:); end - def space_between?(left_bracket_token, right_bracket_token); end - def space_offense(node, token, side, message, command); end - def space_offenses(node, left_token, right_token, message, start_ok: nil, end_ok: nil); end - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::StatementModifier - def code_after(node); end - def comment_disables_cop?(comment); end - def first_line_comment(node); end - def length_in_modifier_form(node); end - def max_line_length; end - def modifier_fits_on_single_line?(node); end - def non_eligible_body?(body); end - def non_eligible_condition?(condition); end - def non_eligible_node?(node); end - def parenthesize?(node); end - def single_line_as_modifier?(node); end - def to_modifier_form(node); end - include RuboCop::Cop::LineLengthHelp -end -module RuboCop::Cop::StringHelp - def inside_interpolation?(node); end - def on_regexp(node); end - def on_str(node); end -end -module RuboCop::Cop::StringLiteralsHelp - def wrong_quotes?(src_or_node); end -end -module RuboCop::Cop::SymbolHelp - def hash_key?(node); end -end -module RuboCop::Cop::TargetRubyVersion - def minimum_target_ruby_version(version); end - def required_minimum_ruby_version; end - def support_target_ruby_version?(version); end -end -module RuboCop::Cop::TrailingBody - def body_on_first_line?(node, body); end - def first_part_of(body); end - def trailing_body?(node); end -end -module RuboCop::Cop::TrailingComma - def allowed_multiline_argument?(node); end - def any_heredoc?(items); end - def autocorrect_range(item); end - def avoid_comma(kind, comma_begin_pos, extra_info); end - def brackets?(node); end - def check(node, items, kind, begin_pos, end_pos); end - def check_comma(node, kind, comma_pos); end - def check_literal(node, kind); end - def comma_offset(items, range); end - def elements(node); end - def extra_avoid_comma_info; end - def heredoc?(node); end - def heredoc_send?(node); end - def inside_comment?(range, comma_offset); end - def method_name_and_arguments_on_same_line?(node); end - def multiline?(node); end - def no_elements_on_same_line?(node); end - def on_same_line?(range1, range2); end - def put_comma(items, kind); end - def should_have_comma?(style, node); end - def style_parameter_name; end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::UncommunicativeName - def allow_nums; end - def allowed_names; end - def arg_range(arg, length); end - def case_offense(node, range); end - def check(node, args); end - def ends_with_num?(name); end - def forbidden_names; end - def forbidden_offense(node, range, name); end - def issue_offenses(node, range, name); end - def length_offense(node, range); end - def long_enough?(name); end - def min_length; end - def name_type(node); end - def num_offense(node, range); end - def uppercase?(name); end -end -module RuboCop::Cop::Lint -end -module RuboCop::Cop::Lint::UnusedArgument - def after_leaving_scope(scope, _variable_table); end - def check_argument(variable); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::VisibilityHelp - def find_visibility_end(node); end - def find_visibility_start(node); end - def node_visibility(node); end - def visibility_block?(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros -end -module RuboCop::Cop::CommentsHelp - def begin_pos_with_comment(node); end - def buffer; end - def contains_comments?(node); end - def end_position_for(node); end - def find_end_line(node); end - def source_range_with_comment(node); end - def start_line_position(node); end -end -module RuboCop::Cop::DefNode - def non_public?(node); end - def non_public_modifier?(param0 = nil); end - def preceding_non_public_modifier?(node); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::Cop::VisibilityHelp -end -module RuboCop::Cop::Utils -end -class RuboCop::Cop::Utils::FormatString - def format_sequences; end - def initialize(string); end - def max_digit_dollar_num; end - def mixed_formats?; end - def named_interpolation?; end - def parse; end - def valid?; end -end -class RuboCop::Cop::Utils::FormatString::FormatSequence - def annotated?; end - def arity; end - def begin_pos; end - def end_pos; end - def flags; end - def initialize(match); end - def max_digit_dollar_num; end - def name; end - def percent?; end - def precision; end - def style; end - def template?; end - def type; end - def width; end -end -module RuboCop::Cop::Migration -end -class RuboCop::Cop::Migration::DepartmentName < RuboCop::Cop::Base - def check_cop_name(name, comment, offset); end - def contain_unexpected_character_for_department_name?(name); end - def disable_comment_offset; end - def on_new_investigation; end - def qualified_legacy_cop_name(cop_name); end - def valid_content_token?(content_token); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::AlignmentCorrector - def self.align_end(corrector, processed_source, node, align_to); end - def self.alignment_column(align_to); end - def self.autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end - def self.block_comment_within?(expr); end - def self.calculate_range(expr, line_begin_pos, column_delta); end - def self.correct(corrector, processed_source, node, column_delta); end - def self.delimited_string_literal?(node); end - def self.each_line(expr); end - def self.inside_string_range(node); end - def self.inside_string_ranges(node); end - def self.processed_source; end - def self.remove(range, corrector); end - def self.whitespace_range(node); end - extend RuboCop::Cop::Alignment - extend RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::ConditionCorrector - def self.correct_negative_condition(corrector, node); end - def self.negated_condition(node); end -end -class RuboCop::Cop::EachToForCorrector - def argument_node; end - def block_node; end - def call(corrector); end - def collection_node; end - def correction; end - def initialize(block_node); end - def offending_range; end - def replacement_range(end_pos); end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::EmptyLineCorrector - def self.correct(corrector, node); end - def self.insert_before(corrector, node); end -end -class RuboCop::Cop::ForToEachCorrector - def call(corrector); end - def collection_end; end - def collection_node; end - def collection_source; end - def correction; end - def end_position; end - def for_node; end - def initialize(for_node); end - def keyword_begin; end - def offending_range; end - def replacement_range(end_pos); end - def requires_parentheses?; end - def variable_node; end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::IfThenCorrector - def branch_body_indentation; end - def call(corrector); end - def if_node; end - def indentation; end - def initialize(if_node, indentation: nil); end - def replacement(node = nil, indentation = nil); end - def rewrite_else_branch(else_branch, indentation); end -end -class RuboCop::Cop::LambdaLiteralToMethodCorrector - def arg_to_unparenthesized_call?; end - def arguments; end - def arguments_begin_pos; end - def arguments_end_pos; end - def block_begin; end - def block_end; end - def block_node; end - def call(corrector); end - def initialize(block_node); end - def insert_arguments(corrector); end - def insert_separating_space(corrector); end - def lambda_arg_string; end - def method; end - def needs_separating_space?; end - def remove_arguments(corrector); end - def remove_leading_whitespace(corrector); end - def remove_trailing_whitespace(corrector); end - def remove_unparenthesized_whitespace(corrector); end - def replace_delimiters(corrector); end - def replace_selector(corrector); end - def selector_end; end - def separating_space?; end -end -class RuboCop::Cop::LineBreakCorrector - def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: nil); end - def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end - def self.move_comment(eol_comment:, node:, corrector:); end - def self.processed_source; end - def self.remove_semicolon(node, corrector); end - def self.semicolon(node); end - def self.trailing_class_definition?(token, body); end - extend RuboCop::Cop::Alignment - extend RuboCop::Cop::TrailingBody - extend RuboCop::Cop::Util -end -class RuboCop::Cop::MultilineLiteralBraceCorrector - def call; end - def content_if_comment_present(corrector, node); end - def correct_next_line_brace(corrector); end - def correct_same_line_brace(corrector); end - def corrector; end - def initialize(corrector, node, processed_source); end - def last_element_range_with_trailing_comma(node); end - def last_element_trailing_comma_range(node); end - def node; end - def processed_source; end - def remove_trailing_content_of_comment(corrector, range); end - def select_content_to_be_inserted_after_last_element(corrector, node); end - def self.correct(corrector, node, processed_source); end - include RuboCop::Cop::MultilineLiteralBraceLayout - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::OrderedGemCorrector - def self.comments_as_separators; end - def self.correct(processed_source, node, previous_declaration, comments_as_separators); end - def self.declaration_with_comment(node); end - def self.processed_source; end - def self.swap_range(corrector, range1, range2); end -end -class RuboCop::Cop::ParenthesesCorrector - def self.correct(corrector, node); end - def self.next_char_is_question_mark?(node); end - def self.ternary_condition?(node); end -end -class RuboCop::Cop::PercentLiteralCorrector - def autocorrect_multiline_words(node, escape, delimiters); end - def autocorrect_words(node, escape, delimiters); end - def config; end - def correct(corrector, node, char); end - def delimiters_for(type); end - def end_content(source); end - def escape_words?(node); end - def first_line?(node, previous_line_num); end - def fix_escaped_content(word_node, escape, delimiters); end - def initialize(config, preferred_delimiters); end - def line_breaks(node, source, previous_line_num, base_line_num, node_indx); end - def new_contents(node, escape, delimiters); end - def preferred_delimiters; end - def process_lines(node, previous_line_num, base_line_num, source_in_lines); end - def process_multiline_words(node, escape, delimiters); end - def substitute_escaped_delimiters(content, delimiters); end - def wrap_contents(corrector, node, contents, char, delimiters); end - include RuboCop::Cop::Util -end -class RuboCop::Cop::PunctuationCorrector - def self.add_space(corrector, token); end - def self.remove_space(corrector, space_before); end - def self.swap_comma(corrector, range); end -end -class RuboCop::Cop::RequireLibraryCorrector - def self.correct(corrector, node, library_name); end - def self.require_statement(library_name); end - extend RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::SpaceCorrector - def self.add_space(processed_source, corrector, left_token, right_token); end - def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end - def self.processed_source; end - def self.remove_space(processed_source, corrector, left_token, right_token); end - extend RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::StringLiteralCorrector - def self.correct(corrector, node, style); end - extend RuboCop::Cop::Util -end -class RuboCop::Cop::UnusedArgCorrector - def self.correct(corrector, processed_source, node); end - def self.correct_for_blockarg_type(corrector, node); end - def self.processed_source; end - extend RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::Bundler -end -class RuboCop::Cop::Bundler::DuplicatedGem < RuboCop::Cop::Base - def conditional_declaration?(nodes); end - def duplicated_gem_nodes; end - def gem_declarations(param0); end - def on_new_investigation; end - def register_offense(node, gem_name, line_of_first_occurrence); end - def within_conditional?(node, conditional_node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Bundler::GemComment < RuboCop::Cop::Base - def checked_options_present?(node); end - def commented?(node); end - def commented_any_descendant?(node); end - def contains_checked_options?(node); end - def gem_options(node); end - def ignored_gem?(node); end - def on_send(node); end - def precede?(node1, node2); end - def preceding_comment?(node1, node2); end - def preceding_lines(node); end - def restrictive_version_specified_gem?(node); end - def version_specified_gem?(node); end - include RuboCop::Cop::DefNode - include RuboCop::Cop::GemDeclaration -end -class RuboCop::Cop::Bundler::GemFilename < RuboCop::Cop::Base - def expected_gemfile?(basename); end - def gemfile_offense?(basename); end - def gemfile_required?; end - def gems_rb_offense?(basename); end - def gems_rb_required?; end - def on_new_investigation; end - def register_gemfile_offense(file_path, basename); end - def register_gems_rb_offense(file_path, basename); end - def register_offense(file_path, basename); end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Bundler::GemVersion < RuboCop::Cop::Base - def allowed_gem?(node); end - def allowed_gems; end - def forbidden_offense?(node); end - def forbidden_style?; end - def includes_commit_reference?(param0 = nil); end - def includes_version_specification?(param0 = nil); end - def message(range); end - def offense?(node); end - def on_send(node); end - def required_offense?(node); end - def required_style?; end - def version_specification?(expression); end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::GemDeclaration -end -class RuboCop::Cop::Bundler::InsecureProtocolSource < RuboCop::Cop::Base - def allow_http_protocol?; end - def insecure_protocol_source?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Bundler::OrderedGems < RuboCop::Cop::Base - def gem_declarations(param0); end - def on_new_investigation; end - def previous_declaration(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::OrderedGemNode -end -module RuboCop::Cop::Gemspec -end -class RuboCop::Cop::Gemspec::DependencyVersion < RuboCop::Cop::Base - def add_dependency_method?(method_name); end - def add_dependency_method_declarations(param0); end - def add_dependency_method_nodes; end - def allowed_gem?(node); end - def allowed_gems; end - def forbidden_offense?(node); end - def forbidden_style?; end - def includes_commit_reference?(param0 = nil); end - def includes_version_specification?(param0 = nil); end - def match_block_variable_name?(receiver_name); end - def message(range); end - def offense?(node); end - def on_new_investigation; end - def required_offense?(node); end - def required_style?; end - def version_specification?(expression); end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::GemspecHelp -end -class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment < RuboCop::Cop::Base - def format_message_from; end - def gem_specification(param0 = nil); end - def node_and_method_name(node, attribute); end - def on_block(block_node); end - def use_deprecated_attributes?(node, block_parameter); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Gemspec::DuplicatedAssignment < RuboCop::Cop::Base - def assignment_method_declarations(param0); end - def duplicated_assignment_method_nodes; end - def match_block_variable_name?(receiver_name); end - def on_new_investigation; end - def register_offense(node, assignment, line_of_first_occurrence); end - include RuboCop::Cop::GemspecHelp - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Gemspec::OrderedDependencies < RuboCop::Cop::Base - def dependency_declarations(param0); end - def get_dependency_name(node); end - def on_new_investigation; end - def previous_declaration(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::OrderedGemNode -end -class RuboCop::Cop::Gemspec::RequireMFA < RuboCop::Cop::Base - def autocorrect(corrector, node, block_var, metadata); end - def change_value(corrector, value); end - def correct_metadata(corrector, metadata); end - def insert_mfa_required(corrector, node, block_var); end - def metadata(param0 = nil); end - def mfa_value(metadata_value); end - def on_block(node); end - def rubygems_mfa_required(param0); end - def true_string?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::GemspecHelp -end -class RuboCop::Cop::Gemspec::RequiredRubyVersion < RuboCop::Cop::Base - def defined_ruby_version(param0 = nil); end - def dynamic_version?(node); end - def extract_ruby_version(required_ruby_version); end - def not_equal_message(required_ruby_version, target_ruby_version); end - def on_new_investigation; end - def on_send(node); end - def required_ruby_version?(param0); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < RuboCop::Cop::Base - def gem_spec_with_ruby_version?(node); end - def on_const(node); end - def ruby_version?(param0 = nil); end - include RuboCop::Cop::GemspecHelp -end -class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check_body(body, node); end - def check_modifier(send_node, end_range); end - def expected_indent_offset; end - def message(range); end - def on_block(node); end - def on_class(node); end - def on_module(node); end - def on_sclass(node); end - def unexpected_indent_offset; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Base - def arguments_or_first_arg_pairs(node); end - def arguments_with_last_arg_pairs(node); end - def autocorrect(corrector, node); end - def autocorrect_incompatible_with_other_cops?; end - def base_column(node, first_argument); end - def enforce_hash_argument_with_separator?; end - def fixed_indentation?; end - def flattened_arguments(node); end - def hash_argument_config; end - def message(_node); end - def multiple_arguments?(node); end - def on_csend(node); end - def on_send(node); end - def target_method_lineno(node); end - def with_first_argument_style?; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def base_column(node, args); end - def fixed_indentation?; end - def message(_range); end - def on_array(node); end - def target_method_lineno(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check_assignment(node, rhs); end - def leftmost_multiple_assignment(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::CheckAssignment -end -class RuboCop::Cop::Layout::BeginEndAlignment < RuboCop::Cop::Base - def alignment_node(node); end - def autocorrect(corrector, node); end - def check_begin_alignment(node); end - def on_kwbegin(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::EndKeywordAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::BlockAlignment < RuboCop::Cop::Base - def add_space_before(corrector, loc, delta); end - def alt_start_msg(start_loc, source_line_column); end - def autocorrect(corrector, node); end - def block_end_align_target(node); end - def block_end_align_target?(param0 = nil, param1); end - def check_block_alignment(start_node, block_node); end - def compute_do_source_line_column(node, end_loc); end - def compute_start_col(ancestor_node, node); end - def disqualified_parent?(parent, node); end - def end_align_target?(node, parent); end - def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end - def format_source_line_column(source_line_column); end - def loc_to_source_line_column(loc); end - def on_block(node); end - def register_offense(block_node, start_loc, end_loc, do_source_line_column); end - def remove_space_before(corrector, end_pos, delta); end - def start_for_block_node(block_node); end - def style_parameter_name; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::BlockEndNewline < RuboCop::Cop::Base - def delimiter_range(node); end - def message(node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::CaseIndentation < RuboCop::Cop::Base - def base_column(case_node, base); end - def check_when(when_node, branch_type); end - def detect_incorrect_style(when_node); end - def end_and_last_conditional_same_line?(node); end - def enforced_style_end?; end - def incorrect_style(when_node, branch_type); end - def indent_one_step?; end - def indentation_width; end - def on_case(case_node); end - def on_case_match(case_match_node); end - def replacement(node); end - def whitespace_range(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::ClassStructure < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def begin_pos_with_comment(node); end - def buffer; end - def categories; end - def class_elements(class_node); end - def classify(node); end - def dynamic_constant?(param0 = nil); end - def end_position_for(node); end - def expected_order; end - def find_category(node); end - def find_heredoc(node); end - def humanize_node(node); end - def ignore?(classification); end - def ignore_for_autocorrect?(node, sibling); end - def on_class(class_node); end - def source_range_with_comment(node); end - def start_line_position(node); end - def walk_over_nested_class_definition(class_node); end - def whole_line_comment_at_line?(line); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::VisibilityHelp -end -class RuboCop::Cop::Layout::ClosingHeredocIndentation < RuboCop::Cop::Base - def argument_indentation_correct?(node); end - def closing_indentation(node); end - def find_node_used_heredoc_argument(node); end - def heredoc_closing(node); end - def heredoc_opening(node); end - def indent_level(source_line); end - def indented_end(node); end - def message(node); end - def on_heredoc(node); end - def opening_indentation(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Heredoc -end -class RuboCop::Cop::Layout::ClosingParenthesisIndentation < RuboCop::Cop::Base - def all_elements_aligned?(elements); end - def autocorrect(corrector, node); end - def check(node, elements); end - def check_for_elements(node, elements); end - def check_for_no_elements(node); end - def correct_column_candidates(node, left_paren); end - def expected_column(left_paren, elements); end - def first_argument_line(elements); end - def indentation_width; end - def line_break_after_left_paren?(left_paren, elements); end - def message(correct_column, left_paren, right_paren); end - def on_begin(node); end - def on_csend(node); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Base - def autocorrect(corrector, comment); end - def autocorrect_one(corrector, comment); end - def autocorrect_preceding_comments(corrector, comment); end - def check(comment, comment_index); end - def correct_indentation(next_line); end - def correctly_aligned_with_preceding_comment?(comment_index, column); end - def less_indented?(line); end - def line_after_comment(comment); end - def message(column, correct_comment_indentation); end - def on_new_investigation; end - def own_line_comment?(comment); end - def should_correct?(preceding_comment, reference_comment); end - def two_alternatives?(line); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::ConditionPosition < RuboCop::Cop::Base - def check(node); end - def message(condition); end - def on_if(node); end - def on_until(node); end - def on_while(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::DefEndAlignment < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::EndKeywordAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::DotPosition < RuboCop::Cop::Base - def ampersand_dot?(node); end - def autocorrect(corrector, dot, node); end - def correct_dot_position_style?(dot_line, selector_line); end - def end_range(node); end - def heredoc?(node); end - def last_heredoc_line(node); end - def line_between?(first_line, second_line); end - def message(dot); end - def on_csend(node); end - def on_send(node); end - def proper_dot_position?(node); end - def receiver_end_line(node); end - def selector_range(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::ElseAlignment < RuboCop::Cop::Base - def assignment_node(node); end - def autocorrect(corrector, node); end - def base_for_method_definition(node); end - def base_range_of_if(node, base); end - def base_range_of_rescue(node); end - def check_alignment(base_range, else_range); end - def check_assignment(node, rhs); end - def check_nested(node, base); end - def on_case(node); end - def on_case_match(node); end - def on_if(node, base = nil); end - def on_rescue(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::CheckAssignment - include RuboCop::Cop::EndKeywordAlignment -end -class RuboCop::Cop::Layout::EmptyComment < RuboCop::Cop::Base - def allow_border_comment?; end - def allow_margin_comment?; end - def autocorrect(corrector, node); end - def comment_text(comment); end - def concat_consecutive_comments(comments); end - def current_token(comment); end - def empty_comment_only?(comment_text); end - def investigate(comments); end - def on_new_investigation; end - def previous_token(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def contains_guard_clause?(node); end - def correct_style?(node); end - def heredoc?(node); end - def heredoc_line(node, heredoc_node); end - def last_heredoc_argument(node); end - def last_heredoc_argument_node(node); end - def multiple_statements_on_line?(node); end - def next_line_empty?(line); end - def next_line_empty_or_enable_directive_comment?(line); end - def next_line_enable_directive_comment?(line); end - def next_line_rescue_or_ensure?(node); end - def next_sibling_empty_or_guard_clause?(node); end - def next_sibling_parent_empty_or_else?(node); end - def offense_location(node); end - def on_if(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::Util - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < RuboCop::Cop::Base - def last_magic_comment(source); end - def offending_range(last_magic_comment); end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < RuboCop::Cop::Base - def autocorrect(node); end - def check_condition(condition); end - def multiline_rescue_exceptions?(exception_nodes); end - def multiline_when_condition?(when_node); end - def next_line_empty?(line); end - def on_case(node); end - def on_if(node); end - def on_rescue(node); end - def on_until(node); end - def on_until_post(node); end - def on_while(node); end - def on_while_post(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLineBetweenDefs < RuboCop::Cop::Base - def allowance_range?; end - def autocorrect(corrector, prev_def, node, count); end - def autocorrect_insert_lines(corrector, newline_pos, count); end - def autocorrect_remove_lines(corrector, newline_pos, count); end - def blank_lines_count_between(first_def_node, second_def_node); end - def candidate?(node); end - def check_defs(nodes); end - def class_candidate?(node); end - def def_end(node); end - def def_start(node); end - def end_loc(node); end - def expected_lines; end - def line_count_allowed?(count); end - def lines_between_defs(first_def_node, second_def_node); end - def maximum_empty_lines; end - def message(node, count: nil); end - def method_candidate?(node); end - def minimum_empty_lines; end - def module_candidate?(node); end - def multiple_blank_lines_groups?(first_def_node, second_def_node); end - def node_type(node); end - def on_begin(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < RuboCop::Cop::Base - def allowed_only_before_style?(node); end - def block_start?(line); end - def body_end?(line); end - def class_def?(line); end - def correct_next_line_if_denied_style(corrector, node, line); end - def empty_lines_around?(node); end - def expected_empty_lines?(node); end - def initialize(config = nil, options = nil); end - def message(node); end - def message_for_around_style(node); end - def message_for_only_before_style(node); end - def next_empty_line_range(node); end - def next_line_empty?(last_send_line); end - def on_block(node); end - def on_class(node); end - def on_module(node); end - def on_sclass(node); end - def on_send(node); end - def previous_line_empty?(send_line); end - def previous_line_ignoring_comments(processed_source, send_line); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLinesAroundArguments < RuboCop::Cop::Base - def empty_lines(node); end - def extra_lines(node); end - def inner_lines(node); end - def line_numbers(node); end - def on_csend(node); end - def on_send(node); end - def outer_lines(node); end - def processed_lines(node); end - def receiver_and_method_call_on_different_lines?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < RuboCop::Cop::Base - def allow_alias?(node); end - def allow_alias_syntax?; end - def attribute_or_allowed_method?(node); end - def autocorrect(corrector, node); end - def next_line_empty?(line); end - def next_line_empty_or_enable_directive_comment?(line); end - def next_line_enable_directive_comment?(line); end - def next_line_node(node); end - def on_send(node); end - def require_empty_line?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < RuboCop::Cop::Base - def on_kwbegin(node); end - def style; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < RuboCop::Cop::Base - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < RuboCop::Cop::Base - def on_class(node); end - def on_sclass(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < RuboCop::Cop::Base - def check_body(body, line_of_def_or_kwbegin); end - def keyword_locations(node); end - def keyword_locations_in_ensure(node); end - def keyword_locations_in_rescue(node); end - def last_rescue_and_end_on_same_line(body); end - def message(location, keyword); end - def on_def(node); end - def on_defs(node); end - def on_kwbegin(node); end - def style; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - def style; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < RuboCop::Cop::Base - def on_module(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Layout::EmptyLinesAroundBody -end -class RuboCop::Cop::Layout::EmptyLines < RuboCop::Cop::Base - def each_extra_empty_line(lines); end - def exceeds_line_offset?(line_diff); end - def on_new_investigation; end - def previous_and_current_lines_empty?(line); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EndAlignment < RuboCop::Cop::Base - def alignment_node(node); end - def alignment_node_for_variable_style(node); end - def asgn_variable_align_with(outer_node, inner_node); end - def assignment_or_operator_method(node); end - def autocorrect(corrector, node); end - def check_asgn_alignment(outer_node, inner_node); end - def check_assignment(node, rhs); end - def check_other_alignment(node); end - def on_case(node); end - def on_class(node); end - def on_if(node); end - def on_module(node); end - def on_until(node); end - def on_while(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::CheckAssignment - include RuboCop::Cop::EndKeywordAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::EndOfLine < RuboCop::Cop::Base - def last_line(processed_source); end - def offense_message(line); end - def on_new_investigation; end - def unimportant_missing_cr?(index, last_line, line); end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::ExtraSpacing < RuboCop::Cop::Base - def align_column(asgn_token); end - def align_equal_sign(corrector, token, align_to); end - def align_equal_signs(range, corrector); end - def aligned_locations(locs); end - def aligned_tok?(token); end - def all_relevant_assignment_lines(line_number); end - def allow_for_trailing_comments?; end - def check_assignment(token); end - def check_other(token1, token2, ast); end - def check_tokens(ast, token1, token2); end - def extra_space_range(token1, token2); end - def force_equal_sign_alignment?; end - def ignored_range?(ast, start_pos); end - def ignored_ranges(ast); end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PrecedingFollowingAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Base - def argument_alignment_config; end - def autocorrect(corrector, node); end - def bare_operator?(node); end - def base_indentation(node); end - def base_range(send_node, arg_node); end - def column_of(range); end - def comment_lines; end - def eligible_method_call?(param0 = nil); end - def enforce_first_argument_with_fixed_indentation?; end - def message(arg_node); end - def on_csend(node); end - def on_new_investigation; end - def on_send(node); end - def previous_code_line(line_number); end - def special_inner_call_indentation?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def base_description(indent_base_type); end - def brace_alignment_style; end - def check(array_node, left_parenthesis); end - def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis); end - def message(base_description); end - def message_for_right_bracket(indent_base_type); end - def on_array(node); end - def on_csend(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MultilineElementIndentation -end -class RuboCop::Cop::Layout::FirstArrayElementLineBreak < RuboCop::Cop::Base - def assignment_on_same_line?(node); end - def on_array(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FirstElementLineBreak -end -class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Base - def argument_alignment_config; end - def autocorrect(corrector, node); end - def base_description(indent_base_type); end - def brace_alignment_style; end - def check(hash_node, left_parenthesis); end - def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end - def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end - def enforce_first_argument_with_fixed_indentation?; end - def message(base_description); end - def message_for_right_brace(indent_base_type); end - def on_csend(node); end - def on_hash(node); end - def on_send(node); end - def separator_style?(first_pair); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MultilineElementIndentation -end -class RuboCop::Cop::Layout::FirstHashElementLineBreak < RuboCop::Cop::Base - def on_hash(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FirstElementLineBreak -end -class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < RuboCop::Cop::Base - def on_csend(node); end - def on_send(node); end - def on_super(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FirstElementLineBreak -end -class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FirstElementLineBreak -end -class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def base_description(_); end - def brace_alignment_style; end - def check(def_node); end - def message(base_description); end - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MultilineElementIndentation -end -class RuboCop::Cop::Layout::HashAlignment < RuboCop::Cop::Base - def add_offenses; end - def adjust(corrector, delta, range); end - def alignment_for(pair); end - def alignment_for_colons; end - def alignment_for_hash_rockets; end - def argument_alignment_config; end - def argument_before_hash(hash_node); end - def autocorrect_incompatible_with_other_cops?(node); end - def check_delta(delta, node:, alignment:); end - def check_pairs(node); end - def column_deltas; end - def column_deltas=(arg0); end - def correct_key_value(corrector, delta, key, value, separator); end - def correct_no_value(corrector, key_delta, key); end - def correct_node(corrector, node, delta); end - def double_splat?(node); end - def enforce_first_argument_with_fixed_indentation?; end - def good_alignment?(column_deltas); end - def ignore_hash_argument?(node); end - def new_alignment(key); end - def offenses_by; end - def offenses_by=(arg0); end - def on_hash(node); end - def on_send(node); end - def on_super(node); end - def on_yield(node); end - def register_offenses_with_format(offenses, format); end - def reset!; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::HashAlignmentStyles - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < RuboCop::Cop::Base - def add_correct_closing_paren(node, corrector); end - def add_correct_external_trailing_comma(node, corrector); end - def autocorrect(corrector, node); end - def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end - def external_trailing_comma?(node); end - def external_trailing_comma_offset_from_loc_end(node); end - def extract_heredoc(node); end - def extract_heredoc_argument(node); end - def find_most_bottom_of_heredoc_end(arguments); end - def fix_closing_parenthesis(node, corrector); end - def fix_external_trailing_comma(node, corrector); end - def heredoc_node?(node); end - def incorrect_parenthesis_removal_begin(node); end - def incorrect_parenthesis_removal_end(node); end - def internal_trailing_comma?(node); end - def internal_trailing_comma_offset_from_last_arg(node); end - def on_send(node); end - def outermost_send_on_same_line(heredoc); end - def remove_incorrect_closing_paren(node, corrector); end - def remove_incorrect_external_trailing_comma(node, corrector); end - def remove_internal_trailing_comma(node, corrector); end - def safe_to_remove_line_containing_closing_paren?(node); end - def self.autocorrect_incompatible_with; end - def send_missing_closing_parens?(parent, child, heredoc); end - def single_line_send_with_heredoc_receiver?(node); end - def space?(pos); end - def subsequent_closing_parentheses_in_same_line?(outermost_send); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::HeredocIndentation < RuboCop::Cop::Base - def adjust_minus(corrector, node); end - def adjust_squiggly(corrector, node); end - def base_indent_level(node); end - def heredoc_body(node); end - def heredoc_end(node); end - def heredoc_indent_type(node); end - def indentation_width; end - def indented_body(node); end - def indented_end(node); end - def line_too_long?(node); end - def longest_line(lines); end - def max_line_length; end - def message(heredoc_indent_type); end - def on_heredoc(node); end - def register_offense(node, heredoc_indent_type); end - def type_message(indentation_width, current_indent_type); end - def unlimited_heredoc_length?; end - def width_message(indentation_width); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Heredoc -end -class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def bare_access_modifier?(node); end - def base_column_for_normal_style(node); end - def check(node); end - def check_indented_internal_methods_style(node); end - def check_normal_style(node); end - def on_begin(node); end - def on_kwbegin(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Layout::IndentationStyle < RuboCop::Cop::Base - def autocorrect(corrector, range); end - def autocorrect_lambda_for_spaces(corrector, range); end - def autocorrect_lambda_for_tabs(corrector, range); end - def find_offense(line, lineno); end - def in_string_literal?(ranges, tabs_range); end - def message(_node); end - def on_new_investigation; end - def string_literal_ranges(ast); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Base - def access_modifier?(param0 = nil); end - def access_modifier_indentation_style; end - def autocorrect(corrector, node); end - def check_assignment(node, rhs); end - def check_if(node, body, else_clause, base_loc); end - def check_indentation(base_loc, body_node, style = nil); end - def check_members(base, members); end - def check_members_for_indented_internal_methods_style(members); end - def check_members_for_normal_style(base, members); end - def check_rescue?(rescue_node); end - def configured_indentation_width; end - def each_member(members); end - def indentation_consistency_style; end - def indentation_to_check?(base_loc, body_node); end - def indented_internal_methods_style?; end - def leftmost_modifier_of(node); end - def message(configured_indentation_width, indentation, name); end - def offending_range(body_node, indentation); end - def offense(body_node, indentation, style); end - def on_block(node); end - def on_case(case_node); end - def on_case_match(case_match); end - def on_class(node); end - def on_csend(node); end - def on_def(node); end - def on_defs(node); end - def on_ensure(node); end - def on_for(node); end - def on_if(node, base = nil); end - def on_kwbegin(node); end - def on_module(node); end - def on_resbody(node); end - def on_rescue(node); end - def on_sclass(node); end - def on_send(node); end - def on_until(node, base = nil); end - def on_while(node, base = nil); end - def other_offense_in_same_range?(node); end - def select_check_member(member); end - def skip_check?(base_loc, body_node); end - def special_modifier?(node); end - def starts_with_access_modifier?(body_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::CheckAssignment - include RuboCop::Cop::EndKeywordAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::InitialIndentation < RuboCop::Cop::Base - def first_token; end - def on_new_investigation; end - def space_before(token); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::LeadingCommentSpace < RuboCop::Cop::Base - def allow_doxygen_comment?; end - def allow_gemfile_ruby_comment?; end - def allowed_on_first_line?(comment); end - def doxygen_comment_style?(comment); end - def gemfile?; end - def gemfile_ruby_comment?(comment); end - def hash_mark(expr); end - def on_new_investigation; end - def rackup_config_file?; end - def rackup_options?(comment); end - def ruby_comment_in_gemfile?(comment); end - def shebang?(comment); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::LeadingEmptyLines < RuboCop::Cop::Base - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Layout::LineContinuationLeadingSpace < RuboCop::Cop::Base - def continuation?(line); end - def investigate(first_line, second_line, range_start); end - def offense_range(range_start, matches); end - def on_dstr(node); end - def raw_lines(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::LineContinuationSpacing < RuboCop::Cop::Base - def autocorrect(corrector, range); end - def comment_ranges(comments); end - def find_offensive_spacing(line); end - def ignore_range?(backtick_range); end - def investigate(line, line_number); end - def last_line(processed_source); end - def message(_range); end - def no_space_style?; end - def on_new_investigation; end - def space_style?; end - def string_literal_ranges(ast); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < RuboCop::Cop::Base - def add_offense_and_correction(node, message); end - def always_indented?(dstr_node); end - def autocorrect(corrector, node); end - def base_column(child); end - def check_aligned(children, start_index); end - def check_indented(children); end - def on_dstr(node); end - def strings_concatenated_with_backslash?(dstr_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Layout::LineLength < RuboCop::Cop::Base - def allow_heredoc?; end - def allowed_heredoc; end - def allowed_line?(line, line_index); end - def breakable_block_range(block_node); end - def breakable_range; end - def breakable_range=(arg0); end - def breakable_range_after_semicolon(semicolon_token); end - def breakable_range_by_line_index; end - def check_directive_line(line, line_index); end - def check_for_breakable_block(block_node); end - def check_for_breakable_node(node); end - def check_for_breakable_semicolons(processed_source); end - def check_line(line, line_index); end - def check_uri_line(line, line_index); end - def excess_range(uri_range, line, line_index); end - def extract_heredocs(ast); end - def heredocs; end - def highlight_start(line); end - def line_in_heredoc?(line_number); end - def line_in_permitted_heredoc?(line_number); end - def max; end - def max=(value); end - def on_array(node); end - def on_block(node); end - def on_hash(node); end - def on_investigation_end; end - def on_new_investigation; end - def on_potential_breakable_node(node); end - def on_send(node); end - def register_offense(loc, line, line_index, length: nil); end - def shebang?(line, line_index); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::CheckLineBreakable - include RuboCop::Cop::LineLengthHelp - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::MultilineArrayBraceLayout < RuboCop::Cop::Base - def on_array(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineLiteralBraceLayout -end -class RuboCop::Cop::Layout::MultilineArrayLineBreaks < RuboCop::Cop::Base - def on_array(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineElementLineBreaks -end -class RuboCop::Cop::Layout::MultilineAssignmentLayout < RuboCop::Cop::Base - def check_assignment(node, rhs); end - def check_by_enforced_style(node, rhs); end - def check_new_line_offense(node, rhs); end - def check_same_line_offense(node, rhs); end - def supported_types; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::CheckAssignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::MultilineBlockLayout < RuboCop::Cop::Base - def add_offense_for_expression(node, expr, msg); end - def args_on_beginning_line?(node); end - def autocorrect(corrector, node); end - def autocorrect_arguments(corrector, node); end - def autocorrect_body(corrector, node, block_body); end - def block_arg_string(node, args); end - def characters_needed_for_space_and_pipes(node); end - def include_trailing_comma?(args); end - def line_break_necessary_in_args?(node); end - def needed_length_for_args(node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::MultilineHashBraceLayout < RuboCop::Cop::Base - def on_hash(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineLiteralBraceLayout -end -class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < RuboCop::Cop::Base - def on_hash(node); end - def starts_with_curly_brace?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineElementLineBreaks -end -class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineElementLineBreaks -end -class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < RuboCop::Cop::Base - def children(node); end - def ignored_literal?(node); end - def on_send(node); end - def single_line_ignoring_receiver?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineLiteralBraceLayout -end -class RuboCop::Cop::Layout::MultilineMethodCallIndentation < RuboCop::Cop::Base - def align_with_base_message(rhs); end - def alignment_base(node, rhs, given_style); end - def autocorrect(corrector, node); end - def base_source; end - def extra_indentation(given_style, parent); end - def first_call_has_a_dot(node); end - def get_dot_right_above(node); end - def message(node, lhs, rhs); end - def no_base_message(lhs, rhs, node); end - def offending_range(node, lhs, rhs, given_style); end - def operation_rhs(node); end - def operator_rhs?(node, receiver); end - def receiver_alignment_base(node); end - def relative_to_receiver_message(rhs); end - def relevant_node?(send_node); end - def right_hand_side(send_node); end - def semantic_alignment_base(node, rhs); end - def semantic_alignment_node(node); end - def should_align_with_base?; end - def should_indent_relative_to_receiver?; end - def syntactic_alignment_base(lhs, rhs); end - def validate_config; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MultilineExpressionIndentation -end -class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MultilineLiteralBraceLayout -end -class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check_and_or(node); end - def message(node, lhs, rhs); end - def offending_range(node, lhs, rhs, given_style); end - def on_and(node); end - def on_or(node); end - def relevant_node?(node); end - def right_hand_side(send_node); end - def should_align?(node, rhs, given_style); end - def validate_config; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MultilineExpressionIndentation -end -class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def base_column(node, args); end - def fixed_indentation?; end - def message(_node); end - def on_def(node); end - def on_defs(node); end - def target_method_lineno(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Layout::RedundantLineBreak < RuboCop::Cop::Base - def check_assignment(node, _rhs); end - def comment_within?(node); end - def configured_to_not_be_inspected?(node); end - def convertible_block?(node); end - def max_line_length; end - def offense?(node); end - def on_send(node); end - def other_cop_takes_precedence?(node); end - def register_offense(node); end - def single_line_block_chain_enabled?; end - def suitable_as_single_line?(node); end - def to_single_line(source); end - def too_long?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::CheckAssignment -end -class RuboCop::Cop::Layout::RescueEnsureAlignment < RuboCop::Cop::Base - def access_modifier?(node); end - def access_modifier_node(node); end - def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end - def aligned_with_line_break_method?(ancestor_node, node); end - def alignment_location(alignment_node); end - def alignment_node(node); end - def alignment_source(node, starting_loc); end - def ancestor_node(node); end - def assignment_node(node); end - def autocorrect(corrector, node, alignment_location); end - def begin_end_alignment_style; end - def check(node); end - def format_message(alignment_node, alignment_loc, kw_loc); end - def modifier?(node); end - def on_ensure(node); end - def on_new_investigation; end - def on_resbody(node); end - def whitespace_range(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::EndKeywordAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SingleLineBlockChain < RuboCop::Cop::Base - def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end - def offending_range(node); end - def on_send(node); end - def selector_range(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceAfterColon < RuboCop::Cop::Base - def followed_by_space?(colon); end - def on_kwoptarg(node); end - def on_pair(node); end - def register_offense(colon); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Layout::SpaceAfterComma < RuboCop::Cop::Base - def kind(token); end - def space_style_before_rcurly; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SpaceAfterPunctuation -end -class RuboCop::Cop::Layout::SpaceAfterMethodName < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceAfterNot < RuboCop::Cop::Base - def on_send(node); end - def whitespace_after_operator?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceAfterSemicolon < RuboCop::Cop::Base - def kind(token); end - def space_style_before_rcurly; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SpaceAfterPunctuation -end -class RuboCop::Cop::Layout::SpaceAroundBlockParameters < RuboCop::Cop::Base - def check_after_closing_pipe(arguments); end - def check_arg(arg); end - def check_closing_pipe_space(arguments, closing_pipe); end - def check_each_arg(args); end - def check_inside_pipes(arguments); end - def check_no_space(space_begin_pos, space_end_pos, msg); end - def check_no_space_style_inside_pipes(arguments); end - def check_opening_pipe_space(arguments, opening_pipe); end - def check_space(space_begin_pos, space_end_pos, range, msg, node = nil); end - def check_space_style_inside_pipes(arguments); end - def last_end_pos_inside_pipes(arguments, range); end - def on_block(node); end - def pipes(arguments); end - def pipes?(arguments); end - def style_parameter_name; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < RuboCop::Cop::Base - def autocorrect(corrector, range); end - def check_optarg(arg, equals, value); end - def incorrect_style_detected(arg, value); end - def message(_node); end - def no_surrounding_space?(arg, equals); end - def on_optarg(node); end - def space_on_both_sides?(arg, equals); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceAroundKeyword < RuboCop::Cop::Base - def accept_left_parenthesis?(range); end - def accept_left_square_bracket?(range); end - def accept_namespace_operator?(range); end - def accepted_opening_delimiter?(range, char); end - def check(node, locations, begin_keyword = nil); end - def check_begin(node, range, begin_keyword); end - def check_end(node, range, begin_keyword); end - def check_keyword(node, range); end - def do?(node); end - def namespace_operator?(range, pos); end - def on_and(node); end - def on_block(node); end - def on_break(node); end - def on_case(node); end - def on_case_match(node); end - def on_defined?(node); end - def on_ensure(node); end - def on_for(node); end - def on_if(node); end - def on_if_guard(node); end - def on_in_pattern(node); end - def on_kwbegin(node); end - def on_match_pattern(node); end - def on_match_pattern_p(node); end - def on_next(node); end - def on_or(node); end - def on_postexe(node); end - def on_preexe(node); end - def on_resbody(node); end - def on_rescue(node); end - def on_return(node); end - def on_send(node); end - def on_super(node); end - def on_unless_guard(node); end - def on_until(node); end - def on_when(node); end - def on_while(node); end - def on_yield(node); end - def on_zsuper(node); end - def preceded_by_operator?(node, _range); end - def safe_navigation_call?(range, pos); end - def space_after_missing?(range); end - def space_before_missing?(range); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < RuboCop::Cop::Base - def check_space(begin_pos, end_pos); end - def check_space_after_dot(node); end - def check_space_after_double_colon(node); end - def check_space_before_dot(node); end - def on_const(node); end - def on_csend(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceAroundOperators < RuboCop::Cop::Base - def align_hash_cop_config; end - def autocorrect(corrector, range); end - def check_operator(type, operator, right_operand); end - def enclose_operator_with_space(corrector, range); end - def excess_leading_space?(type, operator, with_space); end - def excess_trailing_space?(right_operand, with_space); end - def force_equal_sign_alignment?; end - def hash_table_style?; end - def offense(type, operator, with_space, right_operand); end - def offense_message(type, operator, with_space, right_operand); end - def on_and(node); end - def on_and_asgn(node); end - def on_assignment(node); end - def on_binary(node); end - def on_casgn(node); end - def on_class(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_if(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_match_pattern(node); end - def on_op_asgn(node); end - def on_or(node); end - def on_or_asgn(node); end - def on_pair(node); end - def on_resbody(node); end - def on_sclass(node); end - def on_send(node); end - def on_special_asgn(node); end - def operator_with_regular_syntax?(send_node); end - def regular_operator?(send_node); end - def self.autocorrect_incompatible_with; end - def should_not_have_surrounding_space?(operator); end - def space_around_exponent_operator?; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PrecedingFollowingAlignment - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::RationalLiteral -end -class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < RuboCop::Cop::Base - def autocorrect(corrector, range); end - def block_delimiters_style; end - def check_empty(left_brace, space_plus_brace, used_style); end - def check_non_empty(left_brace, space_plus_brace, used_style); end - def conflict_with_block_delimiters?(node); end - def empty_braces?(loc); end - def on_block(node); end - def self.autocorrect_incompatible_with; end - def space_detected(left_brace, space_plus_brace); end - def space_missing(left_brace); end - def style_for_empty_braces; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceBeforeBrackets < RuboCop::Cop::Base - def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos); end - def offense_range(node, begin_pos); end - def offense_range_for_assignment(node, begin_pos); end - def on_send(node); end - def reference_variable_with_brackets?(node); end - def register_offense(range); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceBeforeComma < RuboCop::Cop::Base - def kind(token); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SpaceBeforePunctuation -end -class RuboCop::Cop::Layout::SpaceBeforeComment < RuboCop::Cop::Base - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Layout::SpaceBeforeFirstArg < RuboCop::Cop::Base - def expect_params_after_method_name?(node); end - def no_space_between_method_name_and_first_argument?(node); end - def on_csend(node); end - def on_send(node); end - def regular_method_call_with_arguments?(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PrecedingFollowingAlignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceBeforeSemicolon < RuboCop::Cop::Base - def kind(token); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::SpaceBeforePunctuation -end -class RuboCop::Cop::Layout::SpaceInLambdaLiteral < RuboCop::Cop::Base - def arrow_lambda_with_args?(node); end - def lambda_arguments(node); end - def on_send(node); end - def range_of_offense(node); end - def space_after_arrow(lambda_node); end - def space_after_arrow?(lambda_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < RuboCop::Cop::Base - def each_unnecessary_space_match(node, &blk); end - def on_array(node); end - def on_percent_literal(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MatchRange - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < RuboCop::Cop::Base - def array_brackets(node); end - def autocorrect(corrector, node); end - def compact(corrector, bracket, side); end - def compact_corrections(corrector, node, left, right); end - def compact_offense(node, token, side: nil); end - def compact_offenses(node, left, right, start_ok, end_ok); end - def empty_config; end - def end_has_own_line?(token); end - def index_for(node, token); end - def issue_offenses(node, left, right, start_ok, end_ok); end - def left_array_bracket(node); end - def line_and_column_for(token); end - def multi_dimensional_array?(node, token, side: nil); end - def next_to_bracket?(token, side: nil); end - def next_to_comment?(node, token); end - def next_to_newline?(node, token); end - def on_array(node); end - def qualifies_for_compact?(node, token, side: nil); end - def right_array_bracket(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceInsideBlockBraces < RuboCop::Cop::Base - def adjacent_braces(left_brace, right_brace); end - def aligned_braces?(left_brace, right_brace); end - def braces_with_contents_inside(node, inner); end - def check_inside(node, left_brace, right_brace); end - def check_left_brace(inner, left_brace, args_delimiter); end - def check_right_brace(inner, left_brace, right_brace, single_line); end - def multiline_block?(left_brace, right_brace); end - def no_space(begin_pos, end_pos, msg); end - def no_space_inside_left_brace(left_brace, args_delimiter); end - def offense(begin_pos, end_pos, msg, style_param = nil); end - def on_block(node); end - def on_numblock(node); end - def pipe?(args_delimiter); end - def space(begin_pos, end_pos, msg); end - def space_inside_left_brace(left_brace, args_delimiter); end - def space_inside_right_brace(right_brace); end - def style_for_empty_braces; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < RuboCop::Cop::Base - def ambiguous_or_unexpected_style_detected(style, is_match); end - def autocorrect(corrector, range); end - def check(token1, token2); end - def expect_space?(token1, token2); end - def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end - def message(brace, is_empty_braces, expect_space); end - def offense?(token1, expect_space); end - def on_hash(node); end - def range_of_space_to_the_left(range); end - def range_of_space_to_the_right(range); end - def space_range(token_range); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceInsideParens < RuboCop::Cop::Base - def can_be_ignored?(token1, token2); end - def correct_extaneus_space_between_consecutive_parens(token1, token2); end - def correct_extraneous_space(tokens); end - def correct_extraneous_space_in_empty_parens(token1, token2); end - def correct_missing_space(token1, token2); end - def left_parens?(token1, token2); end - def on_new_investigation; end - def parens?(token1, token2); end - def process_with_compact_style(tokens); end - def process_with_space_style(tokens); end - def right_parens?(token1, token2); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < RuboCop::Cop::Base - def add_offenses_for_unnecessary_spaces(node); end - def on_array(node); end - def on_percent_literal(node); end - def on_xstr(node); end - def regex_matches(node, &blk); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MatchRange - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < RuboCop::Cop::Base - def check(node); end - def on_erange(node); end - def on_irange(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def closing_bracket(tokens, opening_bracket); end - def empty_config; end - def left_ref_bracket(node, tokens); end - def on_send(node); end - def previous_token(current_token); end - def reference_brackets(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < RuboCop::Cop::Base - def autocorrect(corrector, begin_node); end - def delimiters(begin_node); end - def on_interpolation(begin_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::Interpolation - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Layout::TrailingEmptyLines < RuboCop::Cop::Base - def ends_in_end?(processed_source); end - def message(wanted_blank_lines, blank_lines); end - def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Layout::TrailingWhitespace < RuboCop::Cop::Base - def extract_heredocs(ast); end - def find_heredoc(line_number); end - def offense_range(lineno, line); end - def on_heredoc(_node); end - def on_new_investigation; end - def process_line(line, lineno); end - def process_line_in_heredoc(corrector, range, heredoc); end - def skip_heredoc?; end - def static?(heredoc); end - def whitespace_is_indentation?(range, level); end - def whitespace_only?(range); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Heredoc - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::AmbiguousAssignment < RuboCop::Cop::Base - def on_asgn(node); end - def on_casgn(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def rhs(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::AmbiguousBlockAssociation < RuboCop::Cop::Base - def allowed_method?(node); end - def ambiguous_block_association?(send_node); end - def message(send_node); end - def on_csend(node); end - def on_send(node); end - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Lint::AmbiguousOperator < RuboCop::Cop::Base - def find_offense_node_by(diagnostic); end - def message(diagnostic); end - def offense_node(node); end - def offense_position?(node, diagnostic); end - def on_new_investigation; end - def unary_operator?(node, diagnostic); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def greater_precedence?(node1, node2); end - def on_and(node); end - def on_new_investigation; end - def on_send(node); end - def operator?(node); end - def operator_name(node); end - def precedence(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::AmbiguousRange < RuboCop::Cop::Base - def acceptable?(node); end - def acceptable_call?(node); end - def each_boundary(range); end - def on_erange(node); end - def on_irange(node); end - def require_parentheses_for_method_chain?; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < RuboCop::Cop::Base - def find_offense_node(node, regexp_receiver); end - def find_offense_node_by(diagnostic); end - def first_argument_is_regexp?(node); end - def method_chain_to_regexp_receiver?(node, regexp_receiver); end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::AssignmentInCondition < RuboCop::Cop::Base - def allowed_construct?(asgn_node); end - def conditional_assignment?(asgn_node); end - def message(_node); end - def on_if(node); end - def on_until(node); end - def on_while(node); end - def skip_children?(asgn_node); end - def traverse_node(node, &block); end - include RuboCop::Cop::SafeAssignment -end -class RuboCop::Cop::Lint::BigDecimalNew < RuboCop::Cop::Base - def big_decimal_new(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < RuboCop::Cop::Base - def on_and(node); end - def on_or(node); end - def on_send(node); end -end -class RuboCop::Cop::Lint::BooleanSymbol < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def boolean_symbol?(param0 = nil); end - def on_sym(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::CircularArgumentReference < RuboCop::Cop::Base - def check_for_circular_argument_references(arg_name, arg_value); end - def on_kwoptarg(node); end - def on_optarg(node); end -end -class RuboCop::Cop::Lint::ConstantDefinitionInBlock < RuboCop::Cop::Base - def constant_assigned_in_block?(param0 = nil); end - def method_name(node); end - def module_defined_in_block?(param0 = nil); end - def on_casgn(node); end - def on_class(node); end - def on_module(node); end - include RuboCop::Cop::AllowedMethods -end -class RuboCop::Cop::Lint::ConstantOverwrittenInRescue < RuboCop::Cop::Base - def on_resbody(node); end - def overwritten_constant(param0 = nil); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::ConstantResolution < RuboCop::Cop::Base - def allowed_names; end - def const_name?(name); end - def ignored_names; end - def on_const(node); end - def unqualified_const?(param0 = nil); end -end -class RuboCop::Cop::Lint::Debugger < RuboCop::Cop::Base - def debugger_method?(send_node); end - def debugger_methods; end - def kernel?(param0 = nil); end - def message(node); end - def on_send(node); end - def valid_receiver?(param0 = nil, param1); end -end -class RuboCop::Cop::Lint::DeprecatedClassMethods < RuboCop::Cop::Base - def check(node); end - def on_send(node); end - def replacement(deprecated); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod - def class_constant; end - def class_nodes; end - def correctable?; end - def delimiter; end - def initialize(method, class_constant: nil, correctable: nil); end - def method; end - def to_s; end - include RuboCop::AST::Sexp -end -class RuboCop::Cop::Lint::DeprecatedClassMethods::Replacement - def class_constant; end - def delimiter; end - def initialize(method, class_constant: nil, instance_method: nil); end - def instance_method?; end - def method; end - def to_s; end -end -class RuboCop::Cop::Lint::DeprecatedConstants < RuboCop::Cop::Base - def constant_name(node, nested_constant_name); end - def deprecated_constants; end - def message(good, bad, deprecated_version); end - def on_const(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < RuboCop::Cop::Base - def algorithm_const(param0 = nil); end - def algorithm_name(node); end - def autocorrect(corrector, node); end - def build_cipher_arguments(node, algorithm_name, no_arguments); end - def correction_range(node); end - def digest_const?(param0 = nil); end - def message(node); end - def on_send(node); end - def openssl_class(node); end - def replacement_args(node); end - def sanitize_arguments(arguments); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < RuboCop::Cop::Base - def check(node); end - def check_body(body); end - def check_body_lines(lines); end - def check_disjunctive_assignment(node); end - def on_def(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::DuplicateBranch < RuboCop::Cop::Base - def branches(node); end - def consider_branch?(branch); end - def const_branch?(branch); end - def ignore_constant_branches?; end - def ignore_literal_branches?; end - def literal_branch?(branch); end - def offense_range(duplicate_branch); end - def on_branching_statement(node); end - def on_case(node); end - def on_case_match(node); end - def on_if(node); end - def on_rescue(node); end - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Lint::DuplicateCaseCondition < RuboCop::Cop::Base - def on_case(case_node); end -end -class RuboCop::Cop::Lint::DuplicateElsifCondition < RuboCop::Cop::Base - def on_if(node); end -end -class RuboCop::Cop::Lint::DuplicateHashKey < RuboCop::Cop::Base - def on_hash(node); end - include RuboCop::Cop::Duplication -end -class RuboCop::Cop::Lint::DuplicateMethods < RuboCop::Cop::Base - def alias_method?(param0 = nil); end - def check_const_receiver(node, name, const_name); end - def check_self_receiver(node, name); end - def found_attr(node, args, readable: nil, writable: nil); end - def found_instance_method(node, name); end - def found_method(node, method_name); end - def initialize(config = nil, options = nil); end - def lookup_constant(node, const_name); end - def message_for_dup(node, method_name); end - def method_alias?(param0 = nil); end - def on_alias(node); end - def on_attr(node, attr_name, args); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def possible_dsl?(node); end - def qualified_name(enclosing, namespace, mod_name); end - def source_location(node); end - def sym_name(param0 = nil); end -end -class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < RuboCop::Cop::Base - def each_repeated_character_class_element_loc(node); end - def interpolation_locs(node); end - def on_regexp(node); end - def within_interpolation?(node, child); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::DuplicateRequire < RuboCop::Cop::Base - def on_new_investigation; end - def on_send(node); end - def require_call?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::DuplicateRescueException < RuboCop::Cop::Base - def on_rescue(node); end - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Lint::EachWithObjectArgument < RuboCop::Cop::Base - def each_with_object?(param0 = nil); end - def on_csend(node); end - def on_send(node); end -end -class RuboCop::Cop::Lint::ElseLayout < RuboCop::Cop::Base - def autocorrect(corrector, node, first_else); end - def check(node); end - def check_else(node); end - def indentation_width; end - def on_if(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::EmptyBlock < RuboCop::Cop::Base - def allow_comment?(node); end - def allow_empty_lambdas?; end - def comment_disables_cop?(comment); end - def lambda_or_proc?(node); end - def on_block(node); end -end -class RuboCop::Cop::Lint::EmptyClass < RuboCop::Cop::Base - def body_or_allowed_comment_lines?(node); end - def on_class(node); end - def on_sclass(node); end -end -class RuboCop::Cop::Lint::EmptyConditionalBody < RuboCop::Cop::Base - def on_if(node); end - include RuboCop::Cop::CommentsHelp -end -class RuboCop::Cop::Lint::EmptyEnsure < RuboCop::Cop::Base - def on_ensure(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::EmptyExpression < RuboCop::Cop::Base - def empty_expression?(begin_node); end - def on_begin(node); end -end -class RuboCop::Cop::Lint::EmptyFile < RuboCop::Cop::Base - def contains_only_comments?; end - def empty_file?; end - def offending?; end - def on_new_investigation; end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::EmptyInPattern < RuboCop::Cop::Base - def on_case_match(node); end - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::CommentsHelp -end -class RuboCop::Cop::Lint::EmptyInterpolation < RuboCop::Cop::Base - def on_interpolation(begin_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Interpolation -end -class RuboCop::Cop::Lint::EmptyWhen < RuboCop::Cop::Base - def on_case(node); end - include RuboCop::Cop::CommentsHelp -end -class RuboCop::Cop::Lint::EnsureReturn < RuboCop::Cop::Base - def on_ensure(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::ErbNewArguments < RuboCop::Cop::Base - def arguments_range(node); end - def autocorrect(corrector, node); end - def build_kwargs(node); end - def correct_arguments?(arguments); end - def erb_new_with_non_keyword_arguments(param0 = nil); end - def on_send(node); end - def override_by_legacy_args(kwargs, node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::FlipFlop < RuboCop::Cop::Base - def on_eflipflop(node); end - def on_iflipflop(node); end -end -class RuboCop::Cop::Lint::FloatComparison < RuboCop::Cop::Base - def check_numeric_returning_method(node); end - def check_send(node); end - def float?(node); end - def on_send(node); end -end -class RuboCop::Cop::Lint::FloatOutOfRange < RuboCop::Cop::Base - def on_float(node); end -end -class RuboCop::Cop::Lint::FormatParameterMismatch < RuboCop::Cop::Base - def called_on_string?(param0 = nil); end - def count_format_matches(node); end - def count_matches(node); end - def count_percent_matches(node); end - def countable_format?(node); end - def countable_percent?(node); end - def expected_fields_count(node); end - def format?(node); end - def format_method?(name, node); end - def format_string?(node); end - def heredoc?(node); end - def invalid_format_string?(node); end - def matched_arguments_count?(expected, passed); end - def message(node); end - def method_with_format_args?(node); end - def offending_node?(node); end - def on_send(node); end - def percent?(node); end - def splat_args?(node); end - def sprintf?(node); end -end -class RuboCop::Cop::Lint::HashCompareByIdentity < RuboCop::Cop::Base - def id_as_hash_key?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Lint::HeredocMethodCallPosition < RuboCop::Cop::Base - def all_on_same_line?(nodes); end - def autocorrect(corrector, node, heredoc); end - def call_after_heredoc_range(heredoc); end - def call_end_pos(node); end - def call_line_range(node); end - def call_range_to_safely_reposition(node, heredoc); end - def calls_on_multiple_lines?(node, _heredoc); end - def correctly_positioned?(node, heredoc); end - def heredoc_begin_line_range(heredoc); end - def heredoc_end_pos(heredoc); end - def heredoc_node?(node); end - def heredoc_node_descendent_receiver(node); end - def on_csend(node); end - def on_send(node); end - def send_node?(node); end - def trailing_comma?(call_source, call_line_source); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::IdentityComparison < RuboCop::Cop::Base - def compare_between_object_id_by_double_equal?(node); end - def object_id_method?(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::ImplicitStringConcatenation < RuboCop::Cop::Base - def display_str(node); end - def each_bad_cons(node); end - def ending_delimiter(str); end - def on_dstr(node); end - def str_content(node); end - def string_literal?(node); end - def string_literals?(node1, node2); end -end -class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < RuboCop::Cop::Base - def io_select(param0 = nil); end - def on_send(node); end - def preferred_method(read, write, timeout); end - def scheduler_compatible?(io1, io2); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::IneffectiveAccessModifier < RuboCop::Cop::Base - def access_modifier?(node); end - def check_node(node); end - def correct_visibility?(node, modifier, ignored_methods); end - def format_message(modifier); end - def ineffective_modifier(node, ignored_methods = nil, modifier = nil, &block); end - def on_class(node); end - def on_module(node); end - def private_class_method_names(node); end - def private_class_methods(param0); end -end -class RuboCop::Cop::Lint::InheritException < RuboCop::Cop::Base - def class_new_call?(param0 = nil); end - def exception_class?(class_node); end - def message(node); end - def on_class(node); end - def on_send(node); end - def preferred_base_class; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Lint::InterpolationCheck < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def heredoc?(node); end - def on_str(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < RuboCop::Cop::Base - def lambda_with_symbol_proc?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::LiteralAsCondition < RuboCop::Cop::Base - def basic_literal?(node); end - def check_case(case_node); end - def check_for_literal(node); end - def check_node(node); end - def condition(node); end - def handle_node(node); end - def message(node); end - def on_case(case_node); end - def on_case_match(case_match_node); end - def on_if(node); end - def on_send(node); end - def on_until(node); end - def on_until_post(node); end - def on_while(node); end - def on_while_post(node); end - def primitive_array?(node); end - def when_conditions_range(when_node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::LiteralInInterpolation < RuboCop::Cop::Base - def autocorrected_value(node); end - def autocorrected_value_for_array(node); end - def autocorrected_value_for_string(node); end - def autocorrected_value_for_symbol(node); end - def ends_heredoc_line?(node); end - def in_array_percent_literal?(node); end - def offending?(node); end - def on_interpolation(begin_node); end - def prints_as_self?(node); end - def space_literal?(node); end - def special_keyword?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Interpolation - include RuboCop::Cop::PercentLiteral - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::Loop < RuboCop::Cop::Base - def build_break_line(node); end - def keyword_and_condition_range(node); end - def on_until_post(node); end - def on_while_post(node); end - def register_offense(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::MissingCopEnableDirective < RuboCop::Cop::Base - def department_enabled?(cop, comment); end - def each_missing_enable; end - def max_range; end - def message(cop, comment, type = nil); end - def on_new_investigation; end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::MissingSuper < RuboCop::Cop::Base - def callback_method_def?(node); end - def contains_super?(node); end - def inside_class_with_stateful_parent?(node); end - def offender?(node); end - def on_def(node); end - def on_defs(node); end - def stateless_class?(node); end -end -class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < RuboCop::Cop::Base - def on_regexp(node); end -end -class RuboCop::Cop::Lint::MultipleComparison < RuboCop::Cop::Base - def multiple_compare?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::NestedMethodDefinition < RuboCop::Cop::Base - def class_or_module_or_struct_new_call?(param0 = nil); end - def eval_call?(param0 = nil); end - def exec_call?(param0 = nil); end - def on_def(node); end - def on_defs(node); end - def scoping_method_call?(child); end -end -class RuboCop::Cop::Lint::NestedPercentLiteral < RuboCop::Cop::Base - def contains_percent_literals?(node); end - def on_array(node); end - def on_percent_literal(node); end - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Lint::NextWithoutAccumulator < RuboCop::Cop::Base - def on_block(node); end - def on_body_of_reduce(param0 = nil); end - def parent_block_node(node); end -end -class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks < RuboCop::Cop::Base - def on_lvasgn(node); end - def on_op_asgn(node); end - def on_or_asgn(node); end -end -class RuboCop::Cop::Lint::NonAtomicFileOperation < RuboCop::Cop::Base - def allowable_use_with_if?(if_node); end - def autocorrect(corrector, node, range); end - def explicit_not_force?(param0); end - def force?(param0); end - def force_option?(node); end - def message(node); end - def on_send(node); end - def receiver_and_method_name(param0 = nil); end - def register_offense(node, exist_node); end - def replacement_method(node); end - def send_exist_node(param0); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::NonDeterministicRequireOrder < RuboCop::Cop::Base - def correct_block(corrector, node); end - def correct_block_pass(corrector, node); end - def last_arg_range(node); end - def loop_variable(param0 = nil); end - def method_require?(param0 = nil); end - def on_block(node); end - def on_block_pass(node); end - def unsorted_dir_block?(param0 = nil); end - def unsorted_dir_each?(param0 = nil); end - def unsorted_dir_each_pass?(param0 = nil); end - def unsorted_dir_glob_pass?(param0 = nil); end - def unsorted_dir_loop?(node); end - def unsorted_dir_pass?(node); end - def var_is_required?(param0, param1); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::NonLocalExitFromIterator < RuboCop::Cop::Base - def chained_send?(param0 = nil); end - def define_method?(param0 = nil); end - def on_return(return_node); end - def return_value?(return_node); end - def scoped_node?(node); end -end -class RuboCop::Cop::Lint::NumberConversion < RuboCop::Cop::Base - def conversion_method?(method_name); end - def correct_method(node, receiver); end - def correct_sym_method(to_method); end - def handle_as_symbol(node); end - def handle_conversion_method(node); end - def ignore_receiver?(receiver); end - def ignored_class?(name); end - def ignored_classes; end - def on_send(node); end - def remove_parentheses(corrector, node); end - def to_method(param0 = nil); end - def to_method_symbol(param0 = nil); end - def top_receiver(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Lint::NumberedParameterAssignment < RuboCop::Cop::Base - def on_lvasgn(node); end -end -class RuboCop::Cop::Lint::OrAssignmentToConstant < RuboCop::Cop::Base - def on_or_asgn(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::OrderedMagicComments < RuboCop::Cop::Base - def autocorrect(corrector, encoding_line, frozen_string_literal_line); end - def magic_comment_lines; end - def magic_comments; end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FrozenStringLiteral -end -class RuboCop::Cop::Lint::OutOfRangeRegexpRef < RuboCop::Cop::Base - def after_send(node); end - def check_regexp(node); end - def nth_ref_receiver?(send_node); end - def on_match_with_lvasgn(node); end - def on_new_investigation; end - def on_nth_ref(node); end - def on_when(node); end - def regexp_first_argument?(send_node); end - def regexp_receiver?(send_node); end -end -class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < RuboCop::Cop::Base - def chained_calls?(node); end - def first_argument_starts_with_left_parenthesis?(node); end - def on_csend(node); end - def on_send(node); end - def space_range(expr, space_length); end - def spaces_before_left_parenthesis(node); end - def ternary_expression?(node); end - def valid_context?(node); end - def valid_first_argument?(first_arg); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::PercentStringArray < RuboCop::Cop::Base - def contains_quotes_or_commas?(node); end - def on_array(node); end - def on_percent_literal(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Lint::PercentSymbolArray < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def contains_colons_or_commas?(node); end - def non_alphanumeric_literal?(literal); end - def on_array(node); end - def on_percent_literal(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Lint::RaiseException < RuboCop::Cop::Base - def allow_implicit_namespaces; end - def check(node); end - def exception?(param0 = nil); end - def exception_new_with_message?(param0 = nil); end - def implicit_namespace?(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::RandOne < RuboCop::Cop::Base - def message(node); end - def on_send(node); end - def rand_one?(param0 = nil); end -end -class RuboCop::Cop::Lint::RedundantCopDisableDirective < RuboCop::Cop::Base - def add_department_marker(department); end - def add_offense_for_entire_comment(comment, cops); end - def add_offense_for_some_cops(comment, cops); end - def add_offenses(redundant_cops); end - def all_cop_names; end - def all_disabled?(comment); end - def comment_range_with_surrounding_space(directive_comment_range, line_comment_range); end - def cop_disabled_line_ranges; end - def cop_range(comment, cop); end - def department_disabled?(cop, comment); end - def department_marker?(department); end - def describe(cop); end - def directive_count(comment); end - def directive_range_in_list(range, ranges); end - def disabled_ranges; end - def each_already_disabled(cop, line_ranges); end - def each_line_range(cop, line_ranges); end - def each_redundant_disable(&block); end - def ends_its_line?(range); end - def find_redundant_all(range, next_range); end - def find_redundant_cop(cop, range); end - def find_redundant_department(cop, range); end - def followed_ranges?(range, next_range); end - def ignore_offense?(line_range); end - def initialize(config = nil, options = nil, offenses = nil); end - def matching_range(haystack, needle); end - def message(cop_names); end - def offenses_to_check; end - def offenses_to_check=(arg0); end - def on_new_investigation; end - def previous_line_blank?(range); end - def range_with_offense?(range, offenses = nil); end - def remove_department_marker(department); end - def trailing_range?(ranges, range); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RedundantCopEnableDirective < RuboCop::Cop::Base - def all_or_name(name); end - def comment_start(comment); end - def cop_name_indention(comment, name); end - def department?(directive, name); end - def on_new_investigation; end - def range_of_offense(comment, name); end - def range_to_remove(begin_pos, end_pos, comment); end - def range_with_comma(comment, name); end - def range_with_comma_after(comment, start, begin_pos, end_pos); end - def range_with_comma_before(start, begin_pos, end_pos); end - def register_offense(comment, cop_names); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Lint::RedundantDirGlobSort < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Lint::RedundantRequireStatement < RuboCop::Cop::Base - def on_send(node); end - def unnecessary_require_statement?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RedundantSafeNavigation < RuboCop::Cop::Base - def check?(node); end - def condition?(parent, node); end - def on_csend(node); end - def respond_to_nil_specific_method?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RedundantSplatExpansion < RuboCop::Cop::Base - def allow_percent_literal_array_argument?; end - def array_new?(param0 = nil); end - def array_new_inside_array_literal?(array_new_node); end - def array_splat?(node); end - def autocorrect(corrector, node); end - def literal_expansion(param0 = nil); end - def method_argument?(node); end - def on_splat(node); end - def part_of_an_array?(node); end - def redundant_brackets?(node); end - def redundant_splat_expansion(node); end - def remove_brackets(array); end - def replacement_range_and_content(node); end - def use_percent_literal_array_argument?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::RedundantStringCoercion < RuboCop::Cop::Base - def on_interpolation(begin_node); end - def to_s_without_args?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Interpolation -end -class RuboCop::Cop::Lint::RedundantWithIndex < RuboCop::Cop::Base - def message(node); end - def on_block(node); end - def redundant_with_index?(param0 = nil); end - def with_index_range(send); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RedundantWithObject < RuboCop::Cop::Base - def message(node); end - def on_block(node); end - def redundant_with_object?(param0 = nil); end - def with_object_range(send); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RefinementImportMethods < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Lint::RegexpAsCondition < RuboCop::Cop::Base - def on_match_current_line(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::RequireParentheses < RuboCop::Cop::Base - def check_predicate(predicate, node); end - def check_ternary(ternary, node); end - def on_csend(node); end - def on_send(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RequireRelativeSelfPath < RuboCop::Cop::Base - def on_send(node); end - def remove_ext(file_path); end - def same_file?(file_path, required_feature); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::RescueException < RuboCop::Cop::Base - def on_resbody(node); end - def targets_exception?(rescue_arg_node); end -end -class RuboCop::Cop::Lint::RescueType < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def correction(*exceptions); end - def invalid_exceptions(exceptions); end - def on_resbody(node); end - def valid_exceptions(exceptions); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::ReturnInVoidContext < RuboCop::Cop::Base - def non_void_context(return_node); end - def on_return(return_node); end -end -class RuboCop::Cop::Lint::SafeNavigationConsistency < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check(node); end - def location(node, unsafe_method_call); end - def on_csend(node); end - def top_conditional_ancestor(node); end - def unsafe_method_calls(method_calls, safe_nav_receiver); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::IgnoredNode - include RuboCop::Cop::NilMethods -end -class RuboCop::Cop::Lint::SafeNavigationChain < RuboCop::Cop::Base - def bad_method?(param0 = nil); end - def method_chain(node); end - def on_send(node); end - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::NilMethods -end -class RuboCop::Cop::Lint::SafeNavigationWithEmpty < RuboCop::Cop::Base - def on_if(node); end - def safe_navigation_empty_in_conditional?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::ScriptPermission < RuboCop::Cop::Base - def autocorrect(comment); end - def executable?(processed_source); end - def format_message_from(processed_source); end - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::SelfAssignment < RuboCop::Cop::Base - def multiple_self_assignment?(node); end - def on_and_asgn(node); end - def on_casgn(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_or_asgn(node); end - def rhs_matches_lhs?(rhs, lhs); end -end -class RuboCop::Cop::Lint::SendWithMixinArgument < RuboCop::Cop::Base - def bad_location(node); end - def message(method, module_name, bad_method); end - def mixin_method?(node); end - def on_send(node); end - def send_with_mixin_argument?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::ShadowedArgument < RuboCop::Cop::Base - def after_leaving_scope(scope, _variable_table); end - def argument_references(argument); end - def assignment_without_argument_usage(argument); end - def check_argument(argument); end - def ignore_implicit_references?; end - def node_within_block_or_conditional?(node, stop_search_node); end - def reference_pos(node); end - def self.joining_forces; end - def shadowing_assignment(argument); end - def uses_var?(param0, param1); end -end -class RuboCop::Cop::Lint::ShadowedException < RuboCop::Cop::Base - def compare_exceptions(exception, other_exception); end - def contains_multiple_levels_of_exceptions?(group); end - def evaluate_exceptions(group); end - def find_shadowing_rescue(rescues); end - def offense_range(rescues); end - def on_rescue(node); end - def rescued_exceptions(rescue_group); end - def rescued_groups_for(rescues); end - def sorted?(rescued_groups); end - def system_call_err?(error); end - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < RuboCop::Cop::Base - def before_declaring_variable(variable, variable_table); end - def ractor_block?(param0 = nil); end - def same_conditions_node_different_branch?(variable, outer_local_variable); end - def self.joining_forces; end -end -class RuboCop::Cop::Lint::StructNewOverride < RuboCop::Cop::Base - def on_send(node); end - def struct_new(param0 = nil); end -end -class RuboCop::Cop::Lint::SuppressedException < RuboCop::Cop::Base - def comment_between_rescue_and_end?(node); end - def nil_body?(node); end - def on_resbody(node); end -end -class RuboCop::Cop::Lint::SymbolConversion < RuboCop::Cop::Base - def correct_hash_key(node); end - def correct_inconsistent_hash_keys(keys); end - def in_alias?(node); end - def in_percent_literal_array?(node); end - def on_hash(node); end - def on_send(node); end - def on_sym(node); end - def properly_quoted?(source, value); end - def register_offense(node, correction:, message: nil); end - def requires_quotes?(sym_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::SymbolHelp -end -class RuboCop::Cop::Lint::Syntax < RuboCop::Cop::Base - def add_offense_from_diagnostic(diagnostic, ruby_version); end - def add_offense_from_error(error); end - def beautify_message(message); end - def on_other_file; end -end -class RuboCop::Cop::Lint::ToEnumArguments < RuboCop::Cop::Base - def argument_match?(send_arg, def_arg); end - def arguments_match?(arguments, def_node); end - def enum_conversion_call?(param0 = nil); end - def method_name?(param0 = nil, param1); end - def on_send(node); end - def passing_keyword_arg?(param0 = nil, param1); end -end -class RuboCop::Cop::Lint::ToJSON < RuboCop::Cop::Base - def on_def(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::TopLevelReturnWithArgument < RuboCop::Cop::Base - def ancestors_valid?(return_node); end - def on_return(return_node); end -end -class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration < RuboCop::Cop::Base - def on_send(node); end - def trailing_comma_range(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::TripleQuotes < RuboCop::Cop::Base - def empty_str_nodes(node); end - def on_dstr(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::UnderscorePrefixedVariableName < RuboCop::Cop::Base - def after_leaving_scope(scope, _variable_table); end - def allowed_keyword_block_argument?(variable); end - def check_variable(variable); end - def self.joining_forces; end -end -class RuboCop::Cop::Lint::UnexpectedBlockArity < RuboCop::Cop::Base - def acceptable?(node); end - def arg_count(node); end - def expected_arity(method); end - def included_method?(name); end - def methods; end - def on_block(node); end - def on_numblock(node); end -end -class RuboCop::Cop::Lint::UnifiedInteger < RuboCop::Cop::Base - def fixnum_or_bignum_const(param0 = nil); end - def on_const(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator < RuboCop::Cop::Base - def acceptable_return?(return_val, element_name); end - def accumulator_index?(param0 = nil, param1); end - def allowed_type?(parent_node); end - def block_arg_name(node, index); end - def check_return_values(block_node); end - def element_modified?(param0, param1); end - def expression_values(param0); end - def lvar_used?(param0 = nil, param1); end - def on_block(node); end - def on_numblock(node); end - def potential_offense?(return_values, block_body, element_name, accumulator_name); end - def reduce_with_block?(param0 = nil); end - def return_values(block_body_node); end - def returned_accumulator_index(return_values, accumulator_name, element_name); end - def returns_accumulator_anywhere?(return_values, accumulator_name); end -end -class RuboCop::Cop::Lint::UnreachableCode < RuboCop::Cop::Base - def check_case(node); end - def check_if(node); end - def flow_command?(param0 = nil); end - def flow_expression?(node); end - def on_begin(node); end - def on_kwbegin(node); end -end -class RuboCop::Cop::Lint::UnreachableLoop < RuboCop::Cop::Base - def break_command?(param0 = nil); end - def break_statement?(node); end - def check(node); end - def check_case(node); end - def check_if(node); end - def conditional_continue_keyword?(break_statement); end - def loop_method?(node); end - def on_block(node); end - def on_for(node); end - def on_until(node); end - def on_until_post(node); end - def on_while(node); end - def on_while_post(node); end - def preceded_by_continue_statement?(break_statement); end - def statements(node); end - include RuboCop::Cop::AllowedPattern -end -class RuboCop::Cop::Lint::UnusedBlockArgument < RuboCop::Cop::Base - def allow_unused_keyword_arguments?; end - def allowed_block?(variable); end - def allowed_keyword_argument?(variable); end - def augment_message(message, variable); end - def autocorrect(corrector, node); end - def check_argument(variable); end - def define_method_call?(variable); end - def empty_block?(variable); end - def ignore_empty_blocks?; end - def message(variable); end - def message_for_lambda(variable, all_arguments); end - def message_for_normal_block(variable, all_arguments); end - def message_for_underscore_prefix(variable); end - def self.joining_forces; end - def used_block_local?(variable); end - def variable_type(variable); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Lint::UnusedArgument -end -class RuboCop::Cop::Lint::UnusedMethodArgument < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check_argument(variable); end - def ignored_method?(body); end - def message(variable); end - def not_implemented?(param0 = nil); end - def self.joining_forces; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Lint::UnusedArgument -end -class RuboCop::Cop::Lint::UriEscapeUnescape < RuboCop::Cop::Base - def on_send(node); end - def uri_escape_unescape?(param0 = nil); end -end -class RuboCop::Cop::Lint::UriRegexp < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::UselessAccessModifier < RuboCop::Cop::Base - def access_modifier?(node); end - def any_context_creating_methods?(child); end - def any_method_definition?(child); end - def autocorrect(corrector, node); end - def check_child_nodes(node, unused, cur_vis); end - def check_new_visibility(node, unused, new_vis, cur_vis); end - def check_node(node); end - def check_scope(node); end - def check_send_node(node, cur_vis, unused); end - def class_or_instance_eval?(param0 = nil); end - def class_or_module_or_struct_new_call?(param0 = nil); end - def dynamic_method_definition?(param0 = nil); end - def eval_call?(child); end - def method_definition?(child); end - def on_block(node); end - def on_class(node); end - def on_module(node); end - def on_sclass(node); end - def start_of_new_scope?(child); end - def static_method_definition?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::UselessAssignment < RuboCop::Cop::Base - def after_leaving_scope(scope, _variable_table); end - def check_for_unused_assignments(variable); end - def collect_variable_like_names(scope); end - def message_for_useless_assignment(assignment); end - def message_specification(assignment, variable); end - def multiple_assignment_message(variable_name); end - def operator_assignment_message(scope, assignment); end - def return_value_node_of_scope(scope); end - def self.joining_forces; end - def similar_name_message(variable); end - def variable_like_method_invocation?(node); end -end -class RuboCop::Cop::Lint::UselessElseWithoutRescue < RuboCop::Cop::Base - def on_new_investigation; end -end -class RuboCop::Cop::Lint::UselessMethodDefinition < RuboCop::Cop::Base - def delegating?(node, def_node); end - def on_def(node); end - def on_defs(node); end - def optional_args?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::UselessRuby2Keywords < RuboCop::Cop::Base - def allowed_arguments(arguments); end - def inspect_def(node, def_node); end - def inspect_sym(node, sym_node); end - def method_definition(param0 = nil, param1); end - def on_send(node); end -end -class RuboCop::Cop::Lint::UselessSetterCall < RuboCop::Cop::Base - def last_expression(body); end - def on_def(node); end - def on_defs(node); end - def setter_call_to_local_variable?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker - def constructor?(node); end - def contain_local_object?(variable_name); end - def initialize(body_node); end - def process_assignment(asgn_node, rhs_node); end - def process_assignment_node(node); end - def process_binary_operator_assignment(op_asgn_node); end - def process_logical_operator_assignment(asgn_node); end - def process_multiple_assignment(masgn_node); end - def scan(node, &block); end -end -class RuboCop::Cop::Lint::UselessTimes < RuboCop::Cop::Base - def autocorrect(corrector, count, node, proc_name); end - def autocorrect_block(corrector, node); end - def autocorrect_block_pass(corrector, node, proc_name); end - def block_arg(param0 = nil); end - def block_reassigns_arg?(param0, param1); end - def fix_indentation(source, range); end - def never_process?(count, node); end - def on_send(node); end - def own_line?(node); end - def remove_node(corrector, node); end - def times_call?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Lint::Void < RuboCop::Cop::Base - def check_begin(node); end - def check_defined(node); end - def check_expression(expr); end - def check_literal(node); end - def check_nonmutating(node); end - def check_self(node); end - def check_var(node); end - def check_void_op(node); end - def in_void_context?(node); end - def on_begin(node); end - def on_block(node); end - def on_kwbegin(node); end -end -module RuboCop::Cop::Metrics::Utils::IteratingBlock - def block_method_name(node); end - def iterating_block?(node); end - def iterating_method?(name); end -end -class RuboCop::Cop::Metrics::CyclomaticComplexity < RuboCop::Cop::Base - def complexity_score_for(node); end - def count_block?(block); end - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::MethodComplexity - include RuboCop::Cop::Metrics::Utils::IteratingBlock -end -class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator - def argument?(node); end - def assignment?(node); end - def branch?(node); end - def calculate; end - def calculate_node(node); end - def capturing_variable?(name); end - def compound_assignment(node); end - def condition?(node); end - def else_branch?(node); end - def evaluate_branch_nodes(node); end - def evaluate_condition_node(node); end - def initialize(node, discount_repeated_attributes: nil); end - def self.calculate(node, discount_repeated_attributes: nil); end - def simple_assignment?(node); end - def visit_depth_last(node, &block); end - include RuboCop::Cop::Metrics::Utils::IteratingBlock - include RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount -end -class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator - def another_args?(node); end - def build_foldable_checks(types); end - def calculate; end - def classlike_code_length(node); end - def classlike_node?(node); end - def code_length(node); end - def count_comments?; end - def each_top_level_descendant(node, types, &block); end - def extract_body(node); end - def foldable_node?(node); end - def heredoc_length(node); end - def heredoc_node?(node); end - def initialize(node, processed_source, count_comments: nil, foldable_types: nil); end - def irrelevant_line?(source_line); end - def line_numbers_of_inner_nodes(node, *types); end - def namespace_module?(node); end - def normalize_foldable_types(types); end - def omit_length(descendant); end - def parenthesized?(node); end - extend RuboCop::AST::NodePattern::Macros - include RuboCop::Cop::Util -end -class RuboCop::Cop::Metrics::AbcSize < RuboCop::Cop::Base - def complexity(node); end - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::MethodComplexity -end -class RuboCop::Cop::Metrics::BlockLength < RuboCop::Cop::Base - def cop_label; end - def method_receiver_excluded?(node); end - def on_block(node); end - def on_numblock(node); end - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::CodeLength - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Metrics::BlockNesting < RuboCop::Cop::Base - def check_nesting_level(node, max, current_level); end - def consider_node?(node); end - def count_blocks?; end - def max=(value); end - def message(max); end - def on_new_investigation; end -end -class RuboCop::Cop::Metrics::ClassLength < RuboCop::Cop::Base - def message(length, max_length); end - def on_casgn(node); end - def on_class(node); end - include RuboCop::Cop::CodeLength -end -class RuboCop::Cop::Metrics::MethodLength < RuboCop::Cop::Base - def cop_label; end - def on_block(node); end - def on_def(node); end - def on_defs(node); end - def on_numblock(node); end - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::CodeLength - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Metrics::ModuleLength < RuboCop::Cop::Base - def message(length, max_length); end - def module_definition?(param0 = nil); end - def on_casgn(node); end - def on_module(node); end - include RuboCop::Cop::CodeLength -end -class RuboCop::Cop::Metrics::ParameterLists < RuboCop::Cop::Base - def args_count(node); end - def argument_to_lambda_or_proc?(param0 = nil); end - def count_keyword_args?; end - def max=(value); end - def max_optional_parameters; end - def max_optional_parameters=(value); end - def max_params; end - def on_args(node); end - def on_def(node); end - def on_defs(node); end -end -class RuboCop::Cop::Metrics::PerceivedComplexity < RuboCop::Cop::Metrics::CyclomaticComplexity - def complexity_score_for(node); end -end -module RuboCop::Cop::Naming -end -class RuboCop::Cop::Naming::AccessorMethodName < RuboCop::Cop::Base - def bad_reader_name?(node); end - def bad_writer_name?(node); end - def message(node); end - def on_def(node); end - def on_defs(node); end -end -class RuboCop::Cop::Naming::AsciiIdentifiers < RuboCop::Cop::Base - def first_non_ascii_chars(string); end - def first_offense_range(identifier); end - def on_new_investigation; end - def should_check?(token); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Naming::BlockForwarding < RuboCop::Cop::Base - def anonymous_block_argument?(node); end - def block_forwarding_name; end - def expected_block_forwarding_style?(node, last_argument); end - def explicit_block_argument?(node); end - def on_def(node); end - def on_defs(node); end - def register_offense(block_argument, node); end - def use_block_argument_as_local_variable?(node, last_argument); end - def use_kwarg_in_method_definition?(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Naming::BlockParameterName < RuboCop::Cop::Base - def on_block(node); end - include RuboCop::Cop::UncommunicativeName -end -class RuboCop::Cop::Naming::ClassAndModuleCamelCase < RuboCop::Cop::Base - def on_class(node); end - def on_module(node); end -end -class RuboCop::Cop::Naming::ConstantName < RuboCop::Cop::Base - def allowed_assignment?(value); end - def allowed_conditional_expression_on_rhs?(node); end - def allowed_method_call_on_rhs?(node); end - def class_or_struct_return_method?(param0 = nil); end - def contains_contant?(node); end - def literal_receiver?(param0 = nil); end - def on_casgn(node); end -end -class RuboCop::Cop::Naming::FileName < RuboCop::Cop::Base - def allowed_acronyms; end - def bad_filename_allowed?; end - def check_definition_path_hierarchy?; end - def defined_struct(node); end - def definition_path_hierarchy_roots; end - def expect_matching_definition?; end - def filename_good?(basename); end - def find_class_or_module(node, namespace); end - def find_definition(node); end - def for_bad_filename(file_path); end - def ignore_executable_scripts?; end - def match?(expected); end - def match_acronym?(expected, name); end - def match_namespace(node, namespace, expected); end - def matching_class?(file_name); end - def matching_definition?(file_path); end - def no_definition_message(basename, file_path); end - def on_new_investigation; end - def other_message(basename); end - def partial_matcher!(expected); end - def perform_class_and_module_naming_checks(file_path, basename); end - def regex; end - def struct_definition(param0 = nil); end - def to_module_name(basename); end - def to_namespace(path); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Naming::HeredocDelimiterCase < RuboCop::Cop::Base - def correct_case_delimiters?(node); end - def correct_delimiters(source); end - def message(_node); end - def on_heredoc(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::Heredoc -end -class RuboCop::Cop::Naming::HeredocDelimiterNaming < RuboCop::Cop::Base - def forbidden_delimiters; end - def meaningful_delimiters?(node); end - def on_heredoc(node); end - include RuboCop::Cop::Heredoc -end -class RuboCop::Cop::Naming::InclusiveLanguage < RuboCop::Cop::Base - def add_offenses_for_token(token, word_locations); end - def add_to_flagged_term_hash(regex_string, term, term_definition); end - def array_to_ignorecase_regex(strings); end - def check_token?(type); end - def create_message(word, message = nil); end - def create_multiple_word_message_for_file(words); end - def create_single_word_message_for_file(word); end - def ensure_regex_string(regex); end - def extract_regexp(term, term_definition); end - def find_flagged_term(word); end - def format_suggestions(suggestions); end - def initialize(config = nil, options = nil); end - def investigate_filepath; end - def investigate_tokens; end - def mask_input(str); end - def on_new_investigation; end - def preprocess_check_config; end - def preprocess_flagged_terms; end - def preprocess_suggestions(suggestions); end - def process_allowed_regex(allowed); end - def scan_for_words(input); end - def set_regexes(flagged_term_strings, allowed_strings); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < Struct - def position; end - def position=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def word; end - def word=(_); end -end -class RuboCop::Cop::Naming::MemoizedInstanceVariableName < RuboCop::Cop::Base - def defined_memoized?(param0 = nil, param1); end - def find_definition(node); end - def matches?(method_name, ivar_assign); end - def message(variable); end - def method_definition?(param0 = nil); end - def on_defined?(node); end - def on_or_asgn(node); end - def style_parameter_name; end - def suggested_var(method_name); end - def variable_name_candidates(method_name); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Naming::MethodName < RuboCop::Cop::Base - def attr_name(name_item); end - def message(style); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def range_position(node); end - def str_name(param0 = nil); end - def sym_name(param0 = nil); end - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::ConfigurableNaming - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Naming::MethodParameterName < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - include RuboCop::Cop::UncommunicativeName -end -class RuboCop::Cop::Naming::BinaryOperatorParameterName < RuboCop::Cop::Base - def on_def(node); end - def op_method?(name); end - def op_method_candidate?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Naming::PredicateName < RuboCop::Cop::Base - def allowed_method_name?(method_name, prefix); end - def dynamic_method_define(param0 = nil); end - def expected_name(method_name, prefix); end - def forbidden_prefixes; end - def message(method_name, new_name); end - def method_definition_macros(macro_name); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def predicate_prefixes; end - include RuboCop::Cop::AllowedMethods -end -class RuboCop::Cop::Naming::RescuedExceptionsVariableName < RuboCop::Cop::Base - def correct_node(corrector, node, offending_name, preferred_name); end - def correct_reassignment(corrector, node, offending_name, preferred_name); end - def message(node); end - def offense_range(resbody); end - def on_resbody(node); end - def preferred_name(variable_name); end - def shadowed_variable_name?(node); end - def variable_name(node); end - def variable_name_matches?(node, name); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Naming::VariableName < RuboCop::Cop::Base - def message(style); end - def on_arg(node); end - def on_blockarg(node); end - def on_cvasgn(node); end - def on_ivasgn(node); end - def on_kwarg(node); end - def on_kwoptarg(node); end - def on_kwrestarg(node); end - def on_lvar(node); end - def on_lvasgn(node); end - def on_optarg(node); end - def on_restarg(node); end - def valid_name?(node, name, given_style = nil); end - include RuboCop::Cop::AllowedIdentifiers - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::ConfigurableNaming -end -class RuboCop::Cop::Naming::VariableNumber < RuboCop::Cop::Base - def message(style); end - def on_arg(node); end - def on_cvasgn(node); end - def on_def(node); end - def on_defs(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_sym(node); end - def valid_name?(node, name, given_style = nil); end - include RuboCop::Cop::AllowedIdentifiers - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::ConfigurableNumbering -end -module RuboCop::Cop::Style -end -class RuboCop::Cop::Style::AccessModifierDeclarations < RuboCop::Cop::Base - def access_modifier_is_inlined?(node); end - def access_modifier_is_not_inlined?(node); end - def access_modifier_with_symbol?(param0 = nil); end - def allow_modifiers_on_symbols?(node); end - def group_style?; end - def inline_style?; end - def message(range); end - def offense?(node); end - def on_send(node); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::AccessorGrouping < RuboCop::Cop::Base - def accessor?(send_node); end - def autocorrect(corrector, node); end - def check(send_node); end - def class_send_elements(class_node); end - def group_accessors(node, accessors); end - def grouped_style?; end - def message(send_node); end - def on_class(node); end - def on_module(node); end - def on_sclass(node); end - def preferred_accessors(node); end - def previous_line_comment?(node); end - def separate_accessors(node); end - def separated_style?; end - def sibling_accessors(send_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::VisibilityHelp -end -class RuboCop::Cop::Style::Alias < RuboCop::Cop::Base - def add_offense_for_args(node, &block); end - def alias_keyword_possible?(node); end - def alias_method_possible?(node); end - def autocorrect(corrector, node); end - def bareword?(sym_node); end - def correct_alias_method_to_alias(corrector, send_node); end - def correct_alias_to_alias_method(corrector, node); end - def correct_alias_with_symbol_args(corrector, node); end - def identifier(param0 = nil); end - def lexical_scope_type(node); end - def on_alias(node); end - def on_send(node); end - def scope_type(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::AndOr < RuboCop::Cop::Base - def correct_not(node, receiver, corrector); end - def correct_other(node, corrector); end - def correct_send(node, corrector); end - def correct_setter(node, corrector); end - def correctable_send?(node); end - def keep_operator_precedence(corrector, node); end - def message(node); end - def on_and(node); end - def on_conditionals(node); end - def on_if(node); end - def on_or(node); end - def on_until(node); end - def on_until_post(node); end - def on_while(node); end - def on_while_post(node); end - def process_logical_operator(node); end - def whitespace_before_arg(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ArgumentsForwarding < RuboCop::Cop::Base - def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method); end - def allow_only_rest_arguments?; end - def arguments_range(node); end - def extract_argument_names_from(args); end - def forwarding_method?(node, rest_arg, kwargs, block_arg); end - def forwarding_method_arguments?(param0 = nil, param1, param2, param3); end - def on_def(node); end - def on_defs(node); end - def only_rest_arguments?(param0 = nil, param1); end - def register_offense_to_forwarding_method_arguments(forwarding_method); end - def register_offense_to_method_definition_arguments(method_definition); end - def use_rest_arguments?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ArrayCoercion < RuboCop::Cop::Base - def array_splat?(param0 = nil); end - def on_array(node); end - def on_if(node); end - def unless_array?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::ArrayJoin < RuboCop::Cop::Base - def join_candidate?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::AsciiComments < RuboCop::Cop::Base - def allowed_non_ascii_chars; end - def first_non_ascii_chars(string); end - def first_offense_range(comment); end - def on_new_investigation; end - def only_allowed_non_ascii_chars?(string); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::Attr < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def class_eval?(param0 = nil); end - def message(node); end - def on_send(node); end - def replacement_method(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::AutoResourceCleanup < RuboCop::Cop::Base - def cleanup?(node); end - def on_send(node); end -end -class RuboCop::Cop::Style::BarePercentLiterals < RuboCop::Cop::Base - def add_offense_for_wrong_style(node, good, bad); end - def check(node); end - def on_dstr(node); end - def on_str(node); end - def requires_bare_percent?(source); end - def requires_percent_q?(source); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::BeginBlock < RuboCop::Cop::Base - def on_preexe(node); end -end -class RuboCop::Cop::Style::BisectedAttrAccessor < RuboCop::Cop::Base - def after_class(class_node); end - def after_module(class_node); end - def after_sclass(class_node); end - def correct_reader(corrector, macro, node, range); end - def correct_writer(corrector, macro, node, range); end - def find_bisection(macros); end - def find_macros(class_def); end - def on_class(class_node); end - def on_module(class_node); end - def on_new_investigation; end - def on_sclass(class_node); end - def register_offense(attr); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::BisectedAttrAccessor::Macro - def all_bisected?; end - def attr_names; end - def attrs; end - def bisect(*names); end - def bisected_names; end - def bisection; end - def initialize(node); end - def node; end - def reader?; end - def rest; end - def self.macro?(node); end - def visibility; end - def writer?; end - include RuboCop::Cop::VisibilityHelp -end -class RuboCop::Cop::Style::BlockComments < RuboCop::Cop::Base - def eq_end_part(comment, expr); end - def on_new_investigation; end - def parts(comment); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::BlockDelimiters < RuboCop::Cop::Base - def array_or_range?(node); end - def autocorrect(corrector, node); end - def begin_required?(block_node); end - def braces_for_chaining_message(node); end - def braces_for_chaining_style?(node); end - def braces_required_message(node); end - def braces_required_method?(method_name); end - def braces_required_methods; end - def braces_style?(node); end - def conditional?(node); end - def correction_would_break_code?(node); end - def end_of_chain(node); end - def functional_block?(node); end - def functional_method?(method_name); end - def get_blocks(node, &block); end - def line_count_based_block_style?(node); end - def line_count_based_message(node); end - def message(node); end - def move_comment_before_block(corrector, comment, block_node, closing_brace); end - def on_block(node); end - def on_numblock(node); end - def on_send(node); end - def procedural_method?(method_name); end - def procedural_oneliners_may_have_braces?; end - def proper_block_style?(node); end - def replace_braces_with_do_end(corrector, loc); end - def replace_do_end_with_braces(corrector, node); end - def return_value_of_scope?(node); end - def return_value_used?(node); end - def semantic_block_style?(node); end - def semantic_message(node); end - def special_method?(method_name); end - def special_method_proper_block_style?(node); end - def whitespace_after?(range, length = nil); end - def whitespace_before?(range); end - def with_block?(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::IgnoredMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::CaseEquality < RuboCop::Cop::Base - def case_equality?(param0 = nil); end - def const?(node); end - def on_send(node); end - def replacement(lhs, rhs); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::CaseLikeIf < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def branch_conditions(node); end - def class_reference?(node); end - def collect_conditions(node, target, conditions); end - def condition_from_binary_op(lhs, rhs, target); end - def condition_from_equality_node(node, target); end - def condition_from_include_or_cover_node(node, target); end - def condition_from_match_node(node, target); end - def condition_from_send_node(node, target); end - def const_reference?(node); end - def correction_range(node); end - def deparenthesize(node); end - def find_target(node); end - def find_target_in_equality_node(node); end - def find_target_in_include_or_cover_node(node); end - def find_target_in_match_node(node); end - def find_target_in_send_node(node); end - def on_if(node); end - def regexp_with_named_captures?(node); end - def regexp_with_working_captures?(node); end - def should_check?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::CharacterLiteral < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def correct_style_detected; end - def offense?(node); end - def opposite_style_detected; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::StringHelp -end -class RuboCop::Cop::Style::ClassAndModuleChildren < RuboCop::Cop::Base - def add_trailing_end(corrector, node, padding); end - def autocorrect(corrector, node); end - def check_compact_style(node, body); end - def check_nested_style(node); end - def check_style(node, body); end - def compact_definition(corrector, node); end - def compact_identifier_name(node); end - def compact_node(corrector, node); end - def compact_node_name?(node); end - def compact_replacement(node); end - def configured_indentation_width; end - def indent_width; end - def leading_spaces(node); end - def needs_compacting?(body); end - def nest_definition(corrector, node); end - def nest_or_compact(corrector, node); end - def on_class(node); end - def on_module(node); end - def remove_end(corrector, body); end - def replace_namespace_keyword(corrector, node); end - def split_on_double_colon(corrector, node, padding); end - def unindent(corrector, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ClassCheck < RuboCop::Cop::Base - def message(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::ClassEqualityComparison < RuboCop::Cop::Base - def class_comparison_candidate?(param0 = nil); end - def class_name(class_node, node); end - def offense_range(receiver_node, node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::IgnoredMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ClassMethods < RuboCop::Cop::Base - def check_defs(name, node); end - def on_class(node); end - def on_module(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::ClassMethodsDefinitions < RuboCop::Cop::Base - def all_methods_public?(sclass_node); end - def autocorrect_sclass(node, corrector); end - def def_nodes(sclass_node); end - def def_self_style?; end - def extract_def_from_sclass(def_node, sclass_node); end - def indentation_diff(node1, node2); end - def on_defs(node); end - def on_sclass(node); end - def sclass_only_has_methods?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::CommentsHelp - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::VisibilityHelp -end -class RuboCop::Cop::Style::ClassVars < RuboCop::Cop::Base - def on_cvasgn(node); end - def on_send(node); end -end -class RuboCop::Cop::Style::CollectionCompact < RuboCop::Cop::Base - def good_method_name(node); end - def offense_range(node); end - def on_send(node); end - def range(begin_pos_node, end_pos_node); end - def reject_method?(param0 = nil); end - def reject_method_with_block_pass?(param0 = nil); end - def select_method?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::CollectionMethods < RuboCop::Cop::Base - def check_method_node(node); end - def implicit_block?(node); end - def message(node); end - def methods_accepting_symbol; end - def on_block(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MethodPreference -end -class RuboCop::Cop::Style::ColonMethodCall < RuboCop::Cop::Base - def java_type_node?(param0 = nil); end - def on_send(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::ColonMethodDefinition < RuboCop::Cop::Base - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::CombinableLoops < RuboCop::Cop::Base - def collection_looping_method?(node); end - def on_block(node); end - def on_for(node); end - def same_collection_looping?(node, sibling); end -end -class RuboCop::Cop::Style::CommandLiteral < RuboCop::Cop::Base - def allow_inner_backticks?; end - def allowed_backtick_literal?(node); end - def allowed_percent_x_literal?(node); end - def autocorrect(corrector, node); end - def backtick_literal?(node); end - def check_backtick_literal(node, message); end - def check_percent_x_literal(node, message); end - def command_delimiter; end - def contains_backtick?(node); end - def contains_disallowed_backtick?(node); end - def default_delimiter; end - def node_body(node); end - def on_xstr(node); end - def preferred_delimiter; end - def preferred_delimiters_config; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::CommentAnnotation < RuboCop::Cop::Base - def annotation_range(annotation); end - def correct_offense(corrector, range, keyword); end - def first_comment_line?(comments, index); end - def inline_comment?(comment); end - def keywords; end - def on_new_investigation; end - def register_offense(annotation); end - def requires_colon?; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::CommentedKeyword < RuboCop::Cop::Base - def offensive?(comment); end - def on_new_investigation; end - def register_offense(comment, matched_keyword); end - def source_line(comment); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -module RuboCop::Cop::Style::ConditionalAssignmentHelper - def assignment_rhs_exist?(node); end - def end_with_eq?(sym); end - def expand_elses(branch); end - def expand_elsif(node, elsif_branches = nil); end - def expand_when_branches(when_branches); end - def indent(cop, source); end - def lhs(node); end - def lhs_for_casgn(node); end - def lhs_for_send(node); end - def setter_method?(method_name); end - def tail(branch); end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::Cop::Style::ConditionalAssignment < RuboCop::Cop::Base - def allowed_single_line?(branches); end - def allowed_statements?(branches); end - def allowed_ternary?(assignment); end - def assignment_node(node); end - def assignment_type?(param0 = nil); end - def assignment_types_match?(*nodes); end - def autocorrect(corrector, node); end - def candidate_condition?(param0 = nil); end - def candidate_node?(node); end - def check_assignment_to_condition(node); end - def check_node(node, branches); end - def correction_exceeds_line_limit?(node, branches); end - def include_ternary?; end - def indentation_width; end - def lhs_all_match?(branches); end - def line_length_cop_enabled?; end - def longest_line(node, assignment); end - def longest_line_exceeds_line_limit?(node, assignment); end - def max_line_length; end - def move_assignment_inside_condition(corrector, node); end - def move_assignment_outside_condition(corrector, node); end - def on_and_asgn(node); end - def on_case(node); end - def on_case_match(node); end - def on_casgn(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_if(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_op_asgn(node); end - def on_or_asgn(node); end - def on_send(node); end - def single_line_conditions_only?; end - def ternary_condition?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::IgnoredNode - include RuboCop::Cop::Style::ConditionalAssignmentHelper -end -module RuboCop::Cop::Style::ConditionalCorrectorHelper - def assignment(node); end - def correct_branches(corrector, branches); end - def correct_if_branches(corrector, cop, node); end - def remove_whitespace_in_branches(corrector, branch, condition, column); end - def replace_branch_assignment(corrector, branch); end - def white_space_range(node, column); end -end -class RuboCop::Cop::Style::TernaryCorrector - def self.correct(corrector, node); end - def self.correction(node); end - def self.element_assignment?(node); end - def self.extract_branches(node); end - def self.move_assignment_inside_condition(corrector, node); end - def self.move_branch_inside_condition(corrector, branch, assignment); end - def self.remove_parentheses(corrector, node); end - def self.ternary(node); end -end -class RuboCop::Cop::Style::IfCorrector - def self.correct(corrector, cop, node); end - def self.extract_tail_branches(node); end - def self.move_assignment_inside_condition(corrector, node); end - def self.move_branch_inside_condition(corrector, branch, condition, assignment, column); end -end -class RuboCop::Cop::Style::CaseCorrector - def self.correct(corrector, cop, node); end - def self.extract_branches(case_node); end - def self.extract_tail_branches(node); end - def self.move_assignment_inside_condition(corrector, node); end - def self.move_branch_inside_condition(corrector, branch, condition, assignment, column); end -end -class RuboCop::Cop::Style::ConstantVisibility < RuboCop::Cop::Base - def class_or_module_scope?(node); end - def ignore_modules?; end - def match_name?(name, constant_name); end - def message(node); end - def module?(node); end - def on_casgn(node); end - def visibility_declaration?(node); end - def visibility_declaration_for?(param0 = nil, param1); end -end -class RuboCop::Cop::Style::Copyright < RuboCop::Cop::Base - def autocorrect_notice; end - def encoding_token?(processed_source, token_index); end - def insert_notice_before(processed_source); end - def notice; end - def notice_found?(processed_source); end - def offense_range; end - def on_new_investigation; end - def shebang_token?(processed_source, token_index); end - def verify_autocorrect_notice!; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::DateTime < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def date_time?(param0 = nil); end - def disallow_coercion?; end - def historic_date?(param0 = nil); end - def on_send(node); end - def to_datetime?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::DefWithParentheses < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::Dir < RuboCop::Cop::Base - def dir_replacement?(param0 = nil); end - def file_keyword?(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < RuboCop::Cop::Base - def allowed_cops; end - def any_cops_allowed?; end - def directive_cops(comment); end - def on_new_investigation; end - def register_offense(comment, directive_cops, disallowed_cops); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::DocumentationMethod < RuboCop::Cop::Base - def check(node); end - def module_function_node?(param0 = nil); end - def on_def(node); end - def on_defs(node); end - def require_for_non_public_methods?; end - include RuboCop::Cop::DefNode - include RuboCop::Cop::DocumentationComment -end -class RuboCop::Cop::Style::Documentation < RuboCop::Cop::Base - def allowed_constants; end - def check(node, body); end - def compact_namespace?(node); end - def constant_allowed?(node); end - def constant_declaration?(node); end - def constant_definition?(param0 = nil); end - def constant_visibility_declaration?(param0 = nil); end - def identifier(node); end - def macro_only?(body); end - def namespace?(node); end - def nodoc(node); end - def nodoc?(comment, require_all: nil); end - def nodoc_comment?(node, require_all: nil); end - def nodoc_self_or_outer_module?(node); end - def on_class(node); end - def on_module(node); end - def outer_module(param0); end - def qualify_const(node); end - include RuboCop::Cop::DocumentationComment - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::DocumentDynamicEvalDefinition < RuboCop::Cop::Base - def comment_block_docs?(arg_node); end - def comment_regexp(arg_node); end - def heredoc_comment_blocks(heredoc_body); end - def inline_comment_docs?(node); end - def interpolated?(arg_node); end - def merge_adjacent_comments(line, index, hash); end - def on_send(node); end - def preceding_comment_blocks(node); end - def source_to_regexp(source); end -end -class RuboCop::Cop::Style::DoubleCopDisableDirective < RuboCop::Cop::Base - def on_new_investigation; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::DoubleNegation < RuboCop::Cop::Base - def allowed_in_returns?(node); end - def define_mehod?(node); end - def double_negative?(param0 = nil); end - def double_negative_condition_return_value?(node, last_child, conditional_node); end - def end_of_method_definition?(node); end - def find_conditional_node_from_ascendant(node); end - def find_def_node_from_ascendant(node); end - def find_last_child(node); end - def find_parent_not_enumerable(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::EachForSimpleLoop < RuboCop::Cop::Base - def offending_each_range(param0 = nil); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::EachWithObject < RuboCop::Cop::Base - def accumulator_param_assigned_to?(body, args); end - def autocorrect(corrector, node, return_value); end - def each_with_object_candidate?(param0 = nil); end - def first_argument_returned?(args, return_value); end - def on_block(node); end - def return_value(body); end - def return_value_occupies_whole_line?(node); end - def simple_method_arg?(method_arg); end - def whole_line_expression(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyBlockParameter < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::EmptyParameter - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyCaseCondition < RuboCop::Cop::Base - def autocorrect(corrector, case_node); end - def correct_case_when(corrector, case_node, when_nodes); end - def correct_when_conditions(corrector, when_nodes); end - def keep_first_when_comment(case_range, corrector); end - def on_case(case_node); end - def replace_then_with_line_break(corrector, conditions, when_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyElse < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def autocorrect_forbidden?(type); end - def base_node(node); end - def check(node); end - def comment_in_else?(loc); end - def empty_check(node); end - def empty_style?; end - def missing_else_style; end - def nil_check(node); end - def nil_style?; end - def on_case(node); end - def on_normal_if_unless(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::OnNormalIfUnless - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyLambdaParameter < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::EmptyParameter - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyLiteral < RuboCop::Cop::Base - def array_node(param0 = nil); end - def array_with_block(param0 = nil); end - def correction(node); end - def enforce_double_quotes?; end - def first_argument_unparenthesized?(node); end - def frozen_strings?; end - def hash_node(param0 = nil); end - def hash_with_block(param0 = nil); end - def offense_array_node?(node); end - def offense_hash_node?(node); end - def offense_message(node); end - def on_send(node); end - def preferred_string_literal; end - def replacement_range(node); end - def str_node(param0 = nil); end - def string_literals_config; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FrozenStringLiteral - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EmptyMethod < RuboCop::Cop::Base - def compact?(node); end - def compact_style?; end - def correct_style?(node); end - def corrected(node); end - def expanded?(node); end - def expanded_style?; end - def joint(node); end - def max_line_length; end - def message(_range); end - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::EndlessMethod < RuboCop::Cop::Base - def arguments(node, missing = nil); end - def correct_to_multiline(corrector, node); end - def handle_allow_style(node); end - def handle_disallow_style(node); end - def on_def(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::Encoding < RuboCop::Cop::Base - def comments; end - def offense?(comment); end - def on_new_investigation; end - def register_offense(line_number, comment); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::EndBlock < RuboCop::Cop::Base - def on_postexe(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::EnvHome < RuboCop::Cop::Base - def env_home?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::EvalWithLocation < RuboCop::Cop::Base - def add_offense_for_different_line(node, line_node, line_diff); end - def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff); end - def add_offense_for_missing_line(node, code); end - def add_offense_for_missing_location(node, code); end - def add_offense_for_same_line(node, line_node); end - def check_file(node, file_node); end - def check_line(node, code); end - def check_location(node, code); end - def expected_line(sign, line_diff); end - def file_and_line(node); end - def line_difference(line_node, code); end - def line_with_offset?(param0 = nil, param1, param2); end - def missing_line(node, code); end - def on_send(node); end - def register_offense(node, &block); end - def special_file_keyword?(node); end - def special_line_keyword?(node); end - def string_first_line(str_node); end - def valid_eval_receiver?(param0 = nil); end - def with_binding?(node); end - def with_lineno?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::EvenOdd < RuboCop::Cop::Base - def even_odd_candidate?(param0 = nil); end - def on_send(node); end - def replacement_method(arg, method); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::ExpandPathArguments < RuboCop::Cop::Base - def arguments_range(node); end - def autocorrect(corrector, node); end - def autocorrect_expand_path(corrector, current_path, default_dir); end - def depth(current_path); end - def file_expand_path(param0 = nil); end - def inspect_offense_for_expand_path(node, current_path, default_dir); end - def on_send(node); end - def parent_path(current_path); end - def pathname_new_parent_expand_path(param0 = nil); end - def pathname_parent_expand_path(param0 = nil); end - def remove_parent_method(corrector, default_dir); end - def strip_surrounded_quotes!(path_string); end - def unrecommended_argument?(default_dir); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ExplicitBlockArgument < RuboCop::Cop::Base - def add_block_argument(node, corrector, block_name); end - def block_body_range(block_node, send_node); end - def call_like?(node); end - def correct_call_node(node, corrector, block_name); end - def empty_arguments?(node); end - def extract_block_name(def_node); end - def initialize(config = nil, options = nil); end - def insert_argument(node, corrector, block_name); end - def on_yield(node); end - def yielding_arguments?(block_args, yield_args); end - def yielding_block?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ExponentialNotation < RuboCop::Cop::Base - def engineering?(node); end - def integral(node); end - def message(_node); end - def offense?(node); end - def on_float(node); end - def scientific?(node); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::FetchEnvVar < RuboCop::Cop::Base - def allowable_use?(node); end - def allowed_var?(node); end - def assigned?(node); end - def block_control?(param0 = nil); end - def configured_indentation; end - def conterpart_rhs_of(node); end - def default_nil(node, name_node); end - def default_rhs(node, name_node); end - def default_rhs_in_outer_or(node, name_node); end - def default_rhs_in_same_or(node, name_node); end - def default_to_rhs?(node); end - def env_with_bracket?(param0 = nil); end - def first_line_of(source); end - def left_end_of_or_chains?(node); end - def message_chained_with_dot?(node); end - def message_template_for(rhs); end - def new_code_default_nil(name_node); end - def new_code_default_rhs(node, name_node); end - def new_code_default_rhs_multiline(node, name_node); end - def new_code_default_rhs_single_line(node, name_node); end - def offensive?(node); end - def offensive_nodes(param0); end - def on_send(node); end - def operand_of_or?(param0 = nil); end - def or_chain_root(node); end - def partial_matched?(node, condition); end - def rhs_can_be_default_value?(node); end - def rhs_is_block_control?(node); end - def right_end_of_or_chains?(node); end - def used_as_flag?(node); end - def used_if_condition_in_body(node); end - def used_in_condition?(node, condition); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::FileRead < RuboCop::Cop::Base - def block_read?(param0 = nil); end - def evidence(node); end - def file_open?(param0 = nil); end - def file_open_read?(node); end - def on_send(node); end - def read_method(mode); end - def read_node?(node, block_pass); end - def send_read?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::FileWrite < RuboCop::Cop::Base - def block_write?(param0 = nil); end - def evidence(node); end - def file_open?(param0 = nil); end - def file_open_write?(node); end - def heredoc?(write_node); end - def heredoc_range(first_argument); end - def on_send(node); end - def replacement(mode, filename, content, write_node); end - def send_write?(param0 = nil); end - def write_method(mode); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::FloatDivision < RuboCop::Cop::Base - def add_to_f_method(corrector, node); end - def any_coerce?(param0 = nil); end - def both_coerce?(param0 = nil); end - def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end - def extract_receiver_source(node); end - def left_coerce?(param0 = nil); end - def message(_node); end - def offense_condition?(node); end - def on_send(node); end - def remove_to_f_method(corrector, send_node); end - def right_coerce?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::For < RuboCop::Cop::Base - def on_block(node); end - def on_for(node); end - def suspect_enumerable?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::FormatString < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def autocorrect_from_percent(corrector, node); end - def autocorrect_to_percent(corrector, node); end - def format_single_parameter(arg); end - def formatter(param0 = nil); end - def message(detected_style); end - def method_name(style_name); end - def on_send(node); end - def variable_argument?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::FormatStringToken < RuboCop::Cop::Base - def allowed_unannotated?(detections); end - def autocorrect_sequence(corrector, detected_sequence, token_range); end - def check_sequence(detected_sequence, token_range); end - def collect_detections(node); end - def correctable_sequence?(detected_type); end - def format_string_in_typical_context?(param0 = nil); end - def format_string_token?(node); end - def max_unannotated_placeholders_allowed; end - def message(detected_style); end - def message_text(style); end - def on_str(node); end - def str_contents(source_map); end - def token_ranges(contents); end - def tokens(str_node, &block); end - def unannotated_format?(node, detected_style); end - def use_ignored_method?(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Style::FrozenStringLiteralComment < RuboCop::Cop::Base - def disabled_offense(processed_source); end - def enable_comment(corrector); end - def ensure_comment(processed_source); end - def ensure_enabled_comment(processed_source); end - def ensure_no_comment(processed_source); end - def following_comment; end - def frozen_string_literal_comment(processed_source); end - def insert_comment(corrector); end - def last_special_comment(processed_source); end - def line_range(line); end - def missing_offense(processed_source); end - def missing_true_offense(processed_source); end - def on_new_investigation; end - def preceding_comment; end - def remove_comment(corrector, node); end - def unnecessary_comment_offense(processed_source); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::FrozenStringLiteral - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::GlobalStdStream < RuboCop::Cop::Base - def const_to_gvar_assignment?(param0 = nil, param1); end - def gvar_name(const_name); end - def message(const_name); end - def on_const(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::GlobalVars < RuboCop::Cop::Base - def allowed_var?(global_var); end - def check(node); end - def on_gvar(node); end - def on_gvasgn(node); end - def user_vars; end -end -class RuboCop::Cop::Style::GuardClause < RuboCop::Cop::Base - def accepted_form?(node, ending: nil); end - def accepted_if?(node, ending); end - def allowed_consecutive_conditionals?; end - def check_ending_if(node); end - def consecutive_conditionals?(parent, node); end - def guard_clause_source(guard_clause); end - def on_def(node); end - def on_defs(node); end - def on_if(node); end - def register_offense(node, scope_exiting_keyword, conditional_keyword); end - def too_long_for_single_line?(node, example); end - def trivial?(node); end - include RuboCop::Cop::MinBodyLength - include RuboCop::Cop::StatementModifier -end -class RuboCop::Cop::Style::HashAsLastArrayItem < RuboCop::Cop::Base - def braces_style?; end - def check_braces(node); end - def check_no_braces(node); end - def containing_array(hash_node); end - def explicit_array?(array); end - def last_array_item?(array, node); end - def on_hash(node); end - def remove_last_element_trailing_comma(corrector, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::HashConversion < RuboCop::Cop::Base - def allowed_splat_argument?; end - def args_to_hash(args); end - def hash_from_array?(param0 = nil); end - def multi_argument(node); end - def on_send(node); end - def register_offense_for_hash(node, hash_argument); end - def register_offense_for_zip_method(node, zip_method); end - def requires_parens?(node); end - def single_argument(node); end - def use_zip_method_without_argument?(first_argument); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::HashEachMethods < RuboCop::Cop::Base - def allowed_receiver?(receiver); end - def allowed_receivers; end - def check_argument(variable); end - def correct_args(node, corrector); end - def correct_implicit(node, corrector, method_name); end - def correct_key_value_each(node, corrector); end - def kv_each(param0 = nil); end - def kv_range(outer_node); end - def on_block(node); end - def register_kv_offense(node); end - def used?(arg); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Lint::UnusedArgument -end -class RuboCop::Cop::Style::HashExcept < RuboCop::Cop::Base - def bad_method?(block); end - def bad_method_with_active_support?(param0 = nil); end - def bad_method_with_poro?(param0 = nil); end - def decorate_source(value); end - def except_key(node); end - def except_key_source(key); end - def extract_body_if_nagated(body); end - def included?(negated, body); end - def not_included?(negated, body); end - def offense_range(node); end - def on_send(node); end - def safe_to_register_offense?(block, except_key); end - def semantically_except_method?(send, block); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::HashLikeCase < RuboCop::Cop::Base - def hash_like_case?(param0 = nil); end - def min_branches_count; end - def nodes_of_same_type?(nodes); end - def on_case(node); end -end -class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Base - def acceptable_19_syntax_symbol?(sym_name); end - def alternative_style; end - def argument_without_space?(node); end - def autocorrect(corrector, node); end - def autocorrect_hash_rockets(corrector, pair_node); end - def autocorrect_no_mixed_keys(corrector, pair_node); end - def autocorrect_ruby19(corrector, pair_node); end - def check(pairs, delim, msg); end - def force_hash_rockets?(pairs); end - def hash_rockets_check(pairs); end - def no_mixed_keys_check(pairs); end - def on_hash(node); end - def range_for_autocorrect_ruby19(pair_node); end - def ruby19_check(pairs); end - def ruby19_no_mixed_keys_check(pairs); end - def sym_indices?(pairs); end - def word_symbol_pair?(pair); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::HashShorthandSyntax - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::HashTransformKeys < RuboCop::Cop::Base - def extract_captures(match); end - def new_method_name; end - def on_bad_each_with_object(param0 = nil); end - def on_bad_hash_brackets_map(param0 = nil); end - def on_bad_map_to_h(param0 = nil); end - def on_bad_to_h(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::HashTransformMethod -end -class RuboCop::Cop::Style::HashTransformValues < RuboCop::Cop::Base - def extract_captures(match); end - def new_method_name; end - def on_bad_each_with_object(param0 = nil); end - def on_bad_hash_brackets_map(param0 = nil); end - def on_bad_map_to_h(param0 = nil); end - def on_bad_to_h(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::HashTransformMethod -end -class RuboCop::Cop::Style::IdenticalConditionalBranches < RuboCop::Cop::Base - def check_branches(node, branches); end - def check_expressions(node, expressions, insert_position); end - def duplicated_expressions?(node, expressions); end - def expand_elses(branch); end - def head(node); end - def message(node); end - def on_case(node); end - def on_case_match(node); end - def on_if(node); end - def tail(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::IfInsideElse < RuboCop::Cop::Base - def allow_if_modifier?; end - def allow_if_modifier_in_else_branch?(else_branch); end - def autocorrect(corrector, node); end - def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end - def correct_to_elsif_from_modifier_form(corrector, node); end - def find_end_range(node); end - def if_condition_range(node, condition); end - def on_if(node); end - def then?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Base - def allowed_patterns; end - def another_statement_on_same_line?(node); end - def autocorrect(corrector, node); end - def extract_heredoc_from(last_argument); end - def line_length_enabled_at_line?(line); end - def named_capture_in_condition?(node); end - def non_eligible_node?(node); end - def non_simple_if_unless?(node); end - def on_if(node); end - def remove_heredoc(corrector, heredoc); end - def self.autocorrect_incompatible_with; end - def to_normal_form(node, indentation); end - def to_normal_form_with_heredoc(node, indentation, heredoc); end - def too_long_due_to_modifier?(node); end - def too_long_line_based_on_allow_uri?(line); end - def too_long_line_based_on_config?(range, line); end - def too_long_line_based_on_ignore_cop_directives?(range, line); end - def too_long_single_line?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::LineLengthHelp - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::StatementModifier -end -class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < RuboCop::Cop::Base - def on_if(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::StatementModifier -end -class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < RuboCop::Cop::Base - def assume_boolean_value?(condition); end - def double_negative?(param0 = nil); end - def if_with_boolean_literal_branches?(param0 = nil); end - def message(node, keyword); end - def offense_range_with_keyword(node, condition); end - def on_if(node); end - def opposite_condition?(node); end - def replacement_condition(node, condition); end - def require_parentheses?(condition); end - def return_boolean_value?(condition); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedMethods -end -class RuboCop::Cop::Style::IfWithSemicolon < RuboCop::Cop::Base - def autocorrect(node); end - def build_else_branch(second_condition); end - def correct_elsif(node); end - def on_normal_if_unless(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::OnNormalIfUnless -end -class RuboCop::Cop::Style::ImplicitRuntimeError < RuboCop::Cop::Base - def implicit_runtime_error_raise_or_fail(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Style::InPatternThen < RuboCop::Cop::Base - def alternative_pattern_source(pattern); end - def on_in_pattern(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Style::InfiniteLoop < RuboCop::Cop::Base - def after_leaving_scope(scope, _variable_table); end - def assigned_before_loop?(var, range); end - def assigned_inside_loop?(var, range); end - def autocorrect(corrector, node); end - def configured_indent; end - def modifier_replacement(node); end - def non_modifier_range(node); end - def on_until(node); end - def on_until_post(node); end - def on_while(node); end - def on_while_post(node); end - def referenced_after_loop?(var, range); end - def replace_begin_end_with_modifier(corrector, node); end - def replace_source(corrector, range, replacement); end - def self.joining_forces; end - def while_or_until(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::InverseMethods < RuboCop::Cop::Base - def camel_case_constant?(node); end - def correct_inverse_block(corrector, node); end - def correct_inverse_method(corrector, node); end - def correct_inverse_selector(block, corrector); end - def dot_range(loc); end - def end_parentheses(node, method_call); end - def inverse_block?(param0 = nil); end - def inverse_blocks; end - def inverse_candidate?(param0 = nil); end - def inverse_methods; end - def message(method, inverse); end - def negated?(node); end - def not_to_receiver(node, method_call); end - def on_block(node); end - def on_send(node); end - def possible_class_hierarchy_check?(lhs, rhs, method); end - def remove_end_parenthesis(corrector, node, method, method_call); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::IgnoredNode - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::InlineComment < RuboCop::Cop::Base - def on_new_investigation; end -end -class RuboCop::Cop::Style::IpAddresses < RuboCop::Cop::Base - def allowed_addresses; end - def correct_style_detected; end - def could_be_ip?(str); end - def offense?(node); end - def opposite_style_detected; end - def starts_with_hex_or_colon?(str); end - def too_long?(str); end - include RuboCop::Cop::StringHelp -end -class RuboCop::Cop::Style::KeywordParametersOrder < RuboCop::Cop::Base - def append_newline_to_last_kwoptarg(arguments, corrector); end - def on_kwoptarg(node); end - def remove_kwargs(kwarg_nodes, corrector); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::Lambda < RuboCop::Cop::Base - def arguments_with_whitespace(node); end - def autocorrect_method_to_literal(corrector, node); end - def lambda_arg_string(args); end - def message(node, selector); end - def message_line_modifier(node); end - def offending_selector?(node, selector); end - def on_block(node); end - def on_numblock(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::LambdaCall < RuboCop::Cop::Base - def explicit_style?; end - def implicit_style?; end - def offense?(node); end - def on_send(node); end - def prefer(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::LineEndConcatenation < RuboCop::Cop::Base - def autocorrect(corrector, operator_range); end - def check_token_set(index); end - def eligible_next_successor?(next_successor); end - def eligible_operator?(operator); end - def eligible_predecessor?(predecessor); end - def eligible_successor?(successor); end - def eligible_token_set?(predecessor, operator, successor); end - def on_new_investigation; end - def self.autocorrect_incompatible_with; end - def standard_string_literal?(token); end - def token_after_last_string(successor, base_index); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MapToHash < RuboCop::Cop::Base - def autocorrect(corrector, to_h, map); end - def map_to_h?(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < RuboCop::Cop::Base - def any_assignment?(node); end - def default_argument?(node); end - def ineligible_node?(node); end - def offense_range(node); end - def on_send(node); end - def register_offense(node); end - def same_name_assignment?(node); end - def variable_in_mass_assignment?(variable_name, node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Style::MethodCallWithArgsParentheses < RuboCop::Cop::Base - def args_begin(node); end - def args_end(node); end - def args_parenthesized?(node); end - def on_csend(node); end - def on_send(node); end - def on_super(node); end - def on_yield(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::AllowedPattern - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::IgnoredMethods - include RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses - include RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses -end -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses - def allowed_camel_case_method_call?(node); end - def allowed_chained_call_with_parentheses?(node); end - def allowed_multiline_call_with_parentheses?(node); end - def allowed_string_interpolation_method_call?(node); end - def ambigious_literal?(node); end - def assigned_before?(node, target); end - def autocorrect(corrector, node); end - def call_as_argument_or_chain?(node); end - def call_in_literals?(node); end - def call_in_logical_operators?(node); end - def call_in_optional_arguments?(node); end - def call_in_single_line_inheritance?(node); end - def call_with_ambiguous_arguments?(node); end - def call_with_braced_block?(node); end - def exist_next_line_expression?(node); end - def hash_literal?(node); end - def hash_literal_in_arguments?(node); end - def inside_endless_method_def?(node); end - def inside_string_interpolation?(node); end - def legitimate_call_with_parentheses?(node); end - def logical_operator?(node); end - def modifier_form?(node); end - def offense_range(node); end - def omit_parentheses(node); end - def parentheses_at_the_end_of_multiline_call?(node); end - def regexp_slash_literal?(node); end - def require_parentheses_for_hash_value_omission?(node); end - def splat?(node); end - def super_call_without_arguments?(node); end - def syntax_like_method_call?(node); end - def ternary_if?(node); end - def unary_literal?(node); end -end -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses - def eligible_for_parentheses_omission?(node); end - def ignored_macro?(node); end - def included_macros_list; end - def require_parentheses(node); end -end -class RuboCop::Cop::Style::MultilineInPatternThen < RuboCop::Cop::Base - def on_in_pattern(node); end - def require_then?(in_pattern_node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NumberedParameters < RuboCop::Cop::Base - def on_numblock(node); end - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::OpenStructUse < RuboCop::Cop::Base - def custom_class_or_module_definition?(node); end - def on_const(node); end - def uses_open_struct?(param0 = nil); end -end -class RuboCop::Cop::Style::RedundantAssignment < RuboCop::Cop::Base - def check_begin_node(node); end - def check_branch(node); end - def check_case_node(node); end - def check_ensure_node(node); end - def check_if_node(node); end - def check_rescue_node(node); end - def on_def(node); end - def on_defs(node); end - def redundant_assignment?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantFetchBlock < RuboCop::Cop::Base - def basic_literal?(node); end - def build_bad_method(send, body); end - def build_good_method(send, body); end - def check_for_constant?; end - def check_for_string?; end - def const_type?(node); end - def fetch_range(send, node); end - def on_block(node); end - def rails_cache?(param0 = nil); end - def redundant_fetch_block_candidate?(param0 = nil); end - def should_not_check?(send, body); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FrozenStringLiteral - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantFileExtensionInRequire < RuboCop::Cop::Base - def extension_range(name_node); end - def on_send(node); end - def require_call?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantInitialize < RuboCop::Cop::Base - def acceptable?(node); end - def allow_comments?(node); end - def forwards?(node); end - def initialize_forwards?(param0 = nil); end - def on_def(node); end - def register_offense(node, message); end - def same_args?(super_node, args); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::CommentsHelp - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantSelfAssignment < RuboCop::Cop::Base - def correction_range(node); end - def method_returning_self?(method_name); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def on_send(node); end - def redundant_assignment?(node); end - def redundant_nonself_assignment?(param0 = nil, param1, param2); end - def redundant_self_assignment?(param0 = nil, param1); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < RuboCop::Cop::Base - def bad_method?(param0 = nil); end - def inconvertible_to_modifier?(if_branch, else_branch); end - def multiple_statements?(branch); end - def on_lvasgn(node); end - def register_offense(if_node, offense_branch, opposite_branch, keyword); end - def self_assign?(variable, branch); end - def use_if_and_else_branch?(expression); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::SoleNestedConditional < RuboCop::Cop::Base - def allow_modifier?; end - def arguments_range(node); end - def assigned_variables(condition); end - def autocorrect(corrector, node, if_branch); end - def autocorrect_outer_condition_basic(corrector, node, if_branch); end - def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end - def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end - def correct_for_comment(corrector, node, if_branch); end - def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator); end - def correct_for_outer_condition_modify_form_style(corrector, node, if_branch); end - def correct_from_unless_to_if(corrector, node, is_modify_form: nil); end - def correct_outer_condition(corrector, condition); end - def insert_bang(corrector, node, is_modify_form); end - def insert_bang_for_and(corrector, node); end - def offending_branch?(node, branch); end - def on_if(node); end - def outer_condition_modify_form?(node, if_branch); end - def replace_condition(condition); end - def require_parentheses?(condition); end - def self.autocorrect_incompatible_with; end - def use_variable_assignment_in_condition?(condition, if_branch); end - def wrap_condition?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::StaticClass < RuboCop::Cop::Base - def class_convertible_to_module?(class_node); end - def class_elements(class_node); end - def extend_call?(node); end - def on_class(class_node); end - def sclass_convertible_to_module?(node); end - include RuboCop::Cop::VisibilityHelp -end -class RuboCop::Cop::Style::MapCompactWithConditionalBlock < RuboCop::Cop::Base - def map_and_compact?(param0 = nil); end - def on_send(node); end - def range(node); end - def returns_block_argument?(block_argument_node, return_value_node); end - def truthy_branch?(node); end - def truthy_branch_for_guard?(node); end - def truthy_branch_for_if?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < RuboCop::Cop::Base - def on_block(node); end - def on_csend(node); end - def on_send(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MethodDefParentheses < RuboCop::Cop::Base - def anonymous_block_arg?(node); end - def arguments_without_parentheses?(node); end - def correct_arguments(arg_node, corrector); end - def forced_parentheses?(node); end - def missing_parentheses(node); end - def on_def(node); end - def on_defs(node); end - def require_parentheses?(args); end - def unwanted_parentheses(args); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MinMax < RuboCop::Cop::Base - def argument_range(node); end - def message(offender, receiver); end - def min_max_candidate(param0 = nil); end - def offending_range(node); end - def on_array(node); end - def on_return(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::MissingElse < RuboCop::Cop::Base - def case_style?; end - def check(node); end - def empty_else_config; end - def empty_else_cop_enabled?; end - def empty_else_style; end - def if_style?; end - def message_template; end - def on_case(node); end - def on_case_match(node); end - def on_normal_if_unless(node); end - def unless_else_config; end - def unless_else_cop_enabled?; end - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::OnNormalIfUnless -end -class RuboCop::Cop::Style::MissingRespondToMissing < RuboCop::Cop::Base - def implements_respond_to_missing?(node); end - def on_def(node); end - def on_defs(node); end -end -class RuboCop::Cop::Style::MixinGrouping < RuboCop::Cop::Base - def check(send_node); end - def check_grouped_style(send_node); end - def check_separated_style(send_node); end - def group_mixins(node, mixins); end - def grouped_style?; end - def on_class(node); end - def on_module(node); end - def range_to_remove_for_subsequent_mixin(mixins, node); end - def separate_mixins(node); end - def separated_style?; end - def sibling_mixins(send_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::MixinUsage < RuboCop::Cop::Base - def in_top_level_scope?(param0 = nil); end - def include_statement(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Style::ModuleFunction < RuboCop::Cop::Base - def check_extend_self(nodes); end - def check_forbidden(nodes); end - def check_module_function(nodes); end - def each_wrong_style(nodes, &block); end - def extend_self_node?(param0 = nil); end - def message(_range); end - def module_function_node?(param0 = nil); end - def on_module(node); end - def private_directive?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::MultilineBlockChain < RuboCop::Cop::Base - def on_block(node); end - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MultilineIfThen < RuboCop::Cop::Base - def non_modifier_then?(node); end - def on_normal_if_unless(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::OnNormalIfUnless - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MultilineIfModifier < RuboCop::Cop::Base - def configured_indentation_width; end - def indented_body(body, node); end - def on_if(node); end - def to_normal_if(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::StatementModifier -end -class RuboCop::Cop::Style::MultilineMethodSignature < RuboCop::Cop::Base - def arguments_range(node); end - def autocorrect(corrector, node); end - def closing_line(node); end - def correction_exceeds_max_line_length?(node); end - def definition_width(node); end - def indentation_width(node); end - def last_line_source_of_arguments(arguments); end - def max_line_length; end - def on_def(node); end - def on_defs(node); end - def opening_line(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MultilineMemoization < RuboCop::Cop::Base - def bad_rhs?(rhs); end - def keyword_autocorrect(node, corrector); end - def keyword_begin_str(node, node_buf); end - def keyword_end_str(node, node_buf); end - def message(_node); end - def on_or_asgn(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::MultilineTernaryOperator < RuboCop::Cop::Base - def enforce_single_line_ternary_operator?(node); end - def offense?(node); end - def on_if(node); end - def replacement(node); end - def use_assignment_method?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::MultilineWhenThen < RuboCop::Cop::Base - def accept_node_type?(node); end - def on_when(node); end - def require_then?(when_node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::MultipleComparison < RuboCop::Cop::Base - def allow_method_comparison?; end - def comparison?(node); end - def nested_comparison?(node); end - def nested_variable_comparison?(node); end - def on_new_investigation; end - def on_or(node); end - def reset_comparison; end - def root_of_or_node(or_node); end - def simple_comparison_lhs?(param0 = nil); end - def simple_comparison_rhs?(param0 = nil); end - def simple_double_comparison?(param0 = nil); end - def switch_comparison?(node); end - def variable_name(node); end - def variables_in_node(node); end - def variables_in_simple_node(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::MutableConstant < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def check(value); end - def correct_splat_expansion(corrector, expr, splat_value); end - def frozen_regexp_or_range_literals?(node); end - def immutable_literal?(node); end - def mutable_literal?(value); end - def on_assignment(value); end - def on_casgn(node); end - def operation_produces_immutable_object?(param0 = nil); end - def range_enclosed_in_parentheses?(param0 = nil); end - def requires_parentheses?(node); end - def shareable_constant_value?(node); end - def splat_value(param0 = nil); end - def strict_check(value); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::FrozenStringLiteral - include RuboCop::Cop::Style::MutableConstant::ShareableConstantValue -end -module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue - def magic_comment_in_scope(node); end - def processed_source_till_node(node); end - def recent_shareable_value?(node); end - def self.magic_comment_in_scope(node); end - def self.recent_shareable_value?(node); end - def shareable_constant_value_enabled?(value); end -end -class RuboCop::Cop::Style::NegatedIf < RuboCop::Cop::Base - def correct_style?(node); end - def message(node); end - def on_if(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::NegativeConditional -end -class RuboCop::Cop::Style::NegatedIfElseCondition < RuboCop::Cop::Base - def correct_negated_condition(corrector, node); end - def corrected_ancestor?(node); end - def double_negation?(param0 = nil); end - def else_range(node); end - def if_else?(node); end - def if_range(node); end - def negated_condition?(node); end - def on_if(node); end - def on_new_investigation; end - def self.autocorrect_incompatible_with; end - def swap_branches(corrector, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NegatedUnless < RuboCop::Cop::Base - def correct_style?(node); end - def message(node); end - def on_if(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::NegativeConditional -end -class RuboCop::Cop::Style::NegatedWhile < RuboCop::Cop::Base - def on_until(node); end - def on_while(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::NegativeConditional -end -class RuboCop::Cop::Style::NestedFileDirname < RuboCop::Cop::Base - def file_dirname?(param0 = nil); end - def offense_range(node); end - def on_send(node); end - def path_with_dir_level(node, level); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NestedModifier < RuboCop::Cop::Base - def add_parentheses_to_method_arguments(send_node); end - def autocorrect(corrector, node); end - def check(node); end - def left_hand_operand(node, operator); end - def modifier?(node); end - def new_expression(inner_node); end - def on_if(node); end - def on_until(node); end - def on_while(node); end - def replacement_operator(keyword); end - def requires_parens?(node); end - def right_hand_operand(node, left_hand_keyword); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NestedParenthesizedCalls < RuboCop::Cop::Base - def allowed?(send_node); end - def allowed_omission?(send_node); end - def autocorrect(corrector, nested); end - def on_csend(node); end - def on_send(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NestedTernaryOperator < RuboCop::Cop::Base - def autocorrect(corrector, if_node); end - def if_node(node); end - def on_if(node); end - def remove_parentheses(source); end - def replace_loc_and_whitespace(corrector, range, replacement); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::IgnoredNode - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::Next < RuboCop::Cop::Base - def actual_indent(lines, buffer); end - def allowed_modifier_if?(node); end - def autocorrect_block(corrector, node); end - def autocorrect_modifier(corrector, node); end - def check(node); end - def cond_range(node, cond); end - def end_followed_by_whitespace_only?(source_buffer, end_pos); end - def end_range(node); end - def ends_with_condition?(body); end - def exit_body_type?(node); end - def heredoc_lines(node); end - def if_else_children?(node); end - def if_without_else?(node); end - def offense_location(offense_node); end - def offense_node(body); end - def on_block(node); end - def on_for(node); end - def on_new_investigation; end - def on_until(node); end - def on_while(node); end - def reindent(lines, node, corrector); end - def reindent_line(corrector, lineno, delta, buffer); end - def reindentable_lines(node); end - def self.autocorrect_incompatible_with; end - def simple_if_without_break?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::MinBodyLength - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NilComparison < RuboCop::Cop::Base - def message(_node); end - def nil_check?(param0 = nil); end - def nil_comparison?(param0 = nil); end - def on_send(node); end - def prefer_comparison?; end - def style_check?(node, &block); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::NilLambda < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def nil_return?(param0 = nil); end - def on_block(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NonNilCheck < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def autocorrect_comparison(corrector, node); end - def autocorrect_non_nil(corrector, node, inner_node); end - def autocorrect_unless_nil(corrector, node, receiver); end - def include_semantic_changes?; end - def message(node); end - def nil_check?(param0 = nil); end - def nil_comparison_style; end - def not_and_nil_check?(param0 = nil); end - def not_equal_to_nil?(param0 = nil); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def register_offense?(node); end - def unless_and_nil_check?(send_node); end - def unless_check?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::Not < RuboCop::Cop::Base - def correct_opposite_method(corrector, range, child); end - def correct_with_parens(corrector, range, node); end - def correct_without_parens(corrector, range); end - def on_send(node); end - def opposite_method?(child); end - def requires_parens?(child); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::NumberedParametersLimit < RuboCop::Cop::Base - def max=(value); end - def max_count; end - def on_numblock(node); end - extend RuboCop::Cop::TargetRubyVersion - extend RuboCop::ExcludeLimit -end -class RuboCop::Cop::Style::NumericLiterals < RuboCop::Cop::Base - def allowed_numbers; end - def check(node); end - def format_int_part(int_part); end - def format_number(node); end - def min_digits; end - def min_digits=(value); end - def on_float(node); end - def on_int(node); end - def register_offense(node, &_block); end - def short_group_regex; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::IntegerNode -end -class RuboCop::Cop::Style::NumericLiteralPrefix < RuboCop::Cop::Base - def format_binary(source); end - def format_decimal(source); end - def format_hex(source); end - def format_octal(source); end - def format_octal_zero_only(source); end - def hex_bin_dec_literal_type(literal); end - def literal_type(node); end - def message(node); end - def octal_literal_type(literal); end - def octal_zero_only?; end - def on_int(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::IntegerNode -end -class RuboCop::Cop::Style::NumericPredicate < RuboCop::Cop::Base - def check(node); end - def comparison(param0 = nil); end - def invert; end - def inverted_comparison(param0 = nil); end - def on_send(node); end - def parenthesized_source(node); end - def predicate(param0 = nil); end - def replacement(numeric, operation); end - def replacement_supported?(operator); end - def require_parentheses?(node); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::IgnoredMethods -end -class RuboCop::Cop::Style::ObjectThen < RuboCop::Cop::Base - def check_method_node(node); end - def message(node); end - def on_block(node); end - def on_send(node); end - def preferred_method(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::OneLineConditional < RuboCop::Cop::Base - def always_multiline?; end - def autocorrect(corrector, node); end - def cannot_replace_to_ternary?(node); end - def expr_replacement(node); end - def indentation_width; end - def keyword_with_changed_precedence?(node); end - def message(node); end - def method_call_with_changed_precedence?(node); end - def on_normal_if_unless(node); end - def requires_parentheses?(node); end - def ternary_correction(node); end - def ternary_replacement(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::OnNormalIfUnless -end -class RuboCop::Cop::Style::OrAssignment < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_if(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def take_variable_and_default_from_ternary(node); end - def take_variable_and_default_from_unless(node); end - def ternary_assignment?(param0 = nil); end - def unless_assignment?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::OptionHash < RuboCop::Cop::Base - def allowlist; end - def on_args(node); end - def option_hash(param0 = nil); end - def super_used?(node); end - def suspicious_name?(arg_name); end -end -class RuboCop::Cop::Style::OptionalArguments < RuboCop::Cop::Base - def argument_positions(arguments); end - def each_misplaced_optional_arg(arguments); end - def on_def(node); end -end -class RuboCop::Cop::Style::OptionalBooleanParameter < RuboCop::Cop::Base - def format_message(argument); end - def on_def(node); end - def on_defs(node); end - include RuboCop::Cop::AllowedMethods -end -class RuboCop::Cop::Style::ParallelAssignment < RuboCop::Cop::Base - def add_self_to_getters(right_elements); end - def allowed_lhs?(node); end - def allowed_masign?(lhs_elements, rhs_elements); end - def allowed_rhs?(node); end - def assignment_corrector(node, order); end - def autocorrect(corrector, node); end - def find_valid_order(left_elements, right_elements); end - def implicit_self_getter?(param0 = nil); end - def modifier_statement?(node); end - def on_masgn(node); end - def return_of_method_call?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter - def accesses?(rhs, lhs); end - def dependency?(lhs, rhs); end - def initialize(assignments); end - def matching_calls(param0, param1, param2); end - def tsort_each_child(assignment); end - def tsort_each_node(&block); end - def uses_var?(param0, param1); end - def var_name(param0 = nil); end - extend RuboCop::AST::NodePattern::Macros - include TSort -end -class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - def assignment; end - def config; end - def cop_config; end - def correction; end - def correction_range; end - def extract_sources(node); end - def initialize(node, config, new_elements); end - def node; end - def source(node); end - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - def begin_correction(rescue_result); end - def correction; end - def correction_range; end - def def_correction(rescue_result); end -end -class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < RuboCop::Cop::Style::ParallelAssignment::GenericCorrector - def correction; end - def correction_range; end - def modifier_range(node); end -end -class RuboCop::Cop::Style::ParenthesesAroundCondition < RuboCop::Cop::Base - def allow_multiline_conditions?; end - def control_op_condition(param0 = nil); end - def message(node); end - def modifier_op?(node); end - def on_if(node); end - def on_until(node); end - def on_while(node); end - def parens_allowed?(node); end - def process_control_op(node); end - def semicolon_separated_expressions?(first_exp, rest_exps); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Parentheses - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SafeAssignment -end -class RuboCop::Cop::Style::PercentLiteralDelimiters < RuboCop::Cop::Base - def contains_delimiter?(node, delimiters); end - def contains_preferred_delimiter?(node, type); end - def include_same_character_as_used_for_delimiter?(node, type); end - def matchpairs(begin_delimiter); end - def message(type); end - def on_array(node); end - def on_dstr(node); end - def on_percent_literal(node); end - def on_regexp(node); end - def on_str(node); end - def on_sym(node); end - def on_xstr(node); end - def preferred_delimiters_for(type); end - def string_source(node); end - def uses_preferred_delimiter?(node, type); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Style::PercentQLiterals < RuboCop::Cop::Base - def correct_literal_style?(node); end - def corrected(src); end - def message(_range); end - def on_percent_literal(node); end - def on_str(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Style::PerlBackrefs < RuboCop::Cop::Base - def derived_from_braceless_interpolation?(node); end - def format_message(node:, preferred_expression:); end - def on_back_ref(node); end - def on_back_ref_or_gvar_or_nth_ref(node); end - def on_gvar(node); end - def on_nth_ref(node); end - def original_expression_of(node); end - def preferred_expression_to(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::PreferredHashMethods < RuboCop::Cop::Base - def message(method_name); end - def offending_selector?(method_name); end - def on_csend(node); end - def on_send(node); end - def proper_method_name(method_name); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::Proc < RuboCop::Cop::Base - def on_block(node); end - def proc_new?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::QuotedSymbols < RuboCop::Cop::Base - def alternative_style; end - def autocorrect(corrector, node); end - def correct_quotes(str); end - def hash_colon_key?(node); end - def invalid_double_quotes?(source); end - def on_sym(node); end - def quoted?(sym_node); end - def style; end - def wrong_quotes?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::StringLiteralsHelp - include RuboCop::Cop::SymbolHelp -end -class RuboCop::Cop::Style::RaiseArgs < RuboCop::Cop::Base - def acceptable_exploded_args?(args); end - def allowed_non_exploded_type?(arg); end - def check_compact(node); end - def check_exploded(node); end - def correction_compact_to_exploded(node); end - def correction_exploded_to_compact(node); end - def on_send(node); end - def requires_parens?(parent); end - def use_new_method?(first_arg); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::RandomWithOffset < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def boundaries_from_random_node(random_node); end - def corrected_integer_op_rand(node); end - def corrected_rand_modified(node); end - def corrected_rand_op_integer(node); end - def integer_op_rand?(param0 = nil); end - def on_send(node); end - def prefix_from_prefix_node(node); end - def rand_modified?(param0 = nil); end - def rand_op_integer?(param0 = nil); end - def random_call(param0 = nil); end - def to_int(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantArgument < RuboCop::Cop::Base - def argument_range(node); end - def on_send(node); end - def redundant_arg_for_method(method_name); end - def redundant_argument?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantBegin < RuboCop::Cop::Base - def allowable_kwbegin?(node); end - def begin_block_has_multiline_statements?(node); end - def condition_range(node); end - def contain_rescue_or_ensure?(node); end - def correct_modifier_form_after_multiline_begin_block(corrector, node); end - def empty_begin?(node); end - def offensive_kwbegins(param0); end - def on_block(node); end - def on_def(node); end - def on_defs(node); end - def on_kwbegin(node); end - def register_offense(node); end - def replace_begin_with_statement(corrector, offense_range, node); end - def restore_removed_comments(corrector, offense_range, node, first_child); end - def use_modifier_form_after_multiline_begin_block?(node); end - def valid_begin_assignment?(node); end - def valid_context_using_only_begin?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantCapitalW < RuboCop::Cop::Base - def on_array(node); end - def on_percent_literal(node); end - def requires_interpolation?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Style::RedundantCondition < RuboCop::Cop::Base - def asgn_type?(node); end - def branches_have_assignment?(node); end - def branches_have_method?(node); end - def correct_ternary(corrector, node); end - def else_source(else_branch); end - def else_source_if_has_assignment(else_branch); end - def else_source_if_has_method(else_branch); end - def if_source(if_branch); end - def make_ternary_form(node); end - def message(node); end - def offense?(node); end - def on_if(node); end - def range_of_offense(node); end - def redundant_condition?(node); end - def require_braces?(node); end - def require_parentheses?(node); end - def same_method?(if_branch, else_branch); end - def synonymous_condition_and_branch?(node); end - def use_hash_key_access?(node); end - def use_hash_key_assignment?(else_branch); end - def use_if_branch?(else_branch); end - def without_argument_parentheses_method?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantConditional < RuboCop::Cop::Base - def configured_indentation_width; end - def indented_else_node(expression, node); end - def invert_expression?(node); end - def message(node); end - def offense?(node); end - def on_if(node); end - def redundant_condition?(param0 = nil); end - def redundant_condition_inverted?(param0 = nil); end - def replacement_condition(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Style::RedundantException < RuboCop::Cop::Base - def compact?(param0 = nil); end - def exploded?(param0 = nil); end - def fix_compact(node); end - def fix_exploded(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantFreeze < RuboCop::Cop::Base - def immutable_literal?(node); end - def on_send(node); end - def operation_produces_immutable_object?(param0 = nil); end - def strip_parenthesis(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::FrozenStringLiteral -end -class RuboCop::Cop::Style::RedundantInterpolation < RuboCop::Cop::Base - def autocorrect_other(corrector, embedded_node, node); end - def autocorrect_single_variable_interpolation(corrector, embedded_node, node); end - def autocorrect_variable_interpolation(corrector, embedded_node, node); end - def embedded_in_percent_array?(node); end - def implicit_concatenation?(node); end - def interpolation?(node); end - def on_dstr(node); end - def require_parentheses?(node); end - def self.autocorrect_incompatible_with; end - def single_interpolation?(node); end - def single_variable_interpolation?(node); end - def variable_interpolation?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::PercentLiteral -end -class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Base - def allowed_ancestor?(node); end - def allowed_array_or_hash_element?(node); end - def allowed_expression?(node); end - def allowed_method_call?(node); end - def allowed_multiple_expression?(node); end - def arg_in_call_with_block?(param0 = nil); end - def call_chain_starts_with_int?(begin_node, send_node); end - def check(begin_node); end - def check_send(begin_node, node); end - def check_unary(begin_node, node); end - def disallowed_literal?(begin_node, node); end - def empty_parentheses?(node); end - def first_arg_begins_with_hash_literal?(node); end - def first_argument?(node); end - def first_send_argument?(param0 = nil); end - def first_super_argument?(param0 = nil); end - def first_yield_argument?(param0 = nil); end - def hash_or_array_element?(node); end - def ignore_syntax?(node); end - def interpolation?(param0 = nil); end - def keyword_ancestor?(node); end - def keyword_with_redundant_parentheses?(node); end - def like_method_argument_parentheses?(node); end - def method_call_with_redundant_parentheses?(node); end - def method_chain_begins_with_hash_literal?(node); end - def method_node_and_args(param0 = nil); end - def offense(node, msg); end - def on_begin(node); end - def only_begin_arg?(args); end - def only_closing_paren_before_comma?(node); end - def parens_allowed?(node); end - def raised_to_power_negative_numeric?(begin_node, node); end - def range_end?(param0 = nil); end - def rescue?(param0 = nil); end - def square_brackets?(param0 = nil); end - def suspect_unary?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Parentheses -end -class RuboCop::Cop::Style::RedundantPercentQ < RuboCop::Cop::Base - def acceptable_capital_q?(node); end - def acceptable_q?(node); end - def allowed_percent_q?(node); end - def check(node); end - def interpolated_quotes?(node); end - def message(node); end - def on_dstr(node); end - def on_str(node); end - def start_with_percent_q_variant?(string); end - def string_literal?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantRegexpCharacterClass < RuboCop::Cop::Base - def backslash_b?(elem); end - def each_redundant_character_class(node); end - def each_single_element_character_class(node); end - def multiple_codepoins?(expression); end - def on_regexp(node); end - def redundant_single_element_character_class?(node, char_class); end - def requires_escape_outside_char_class?(elem); end - def whitespace_in_free_space_mode?(node, elem); end - def without_character_class(loc); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantRegexpEscape < RuboCop::Cop::Base - def allowed_escape?(node, char, within_character_class); end - def delimiter?(node, char); end - def each_escape(node); end - def escape_range_at_index(node, index); end - def on_regexp(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantReturn < RuboCop::Cop::Base - def add_braces(corrector, node); end - def add_brackets(corrector, node); end - def allow_multiple_return_values?; end - def check_begin_node(node); end - def check_branch(node); end - def check_case_node(node); end - def check_ensure_node(node); end - def check_if_node(node); end - def check_resbody_node(node); end - def check_rescue_node(node); end - def check_return_node(node); end - def correct_with_arguments(return_node, corrector); end - def correct_without_arguments(return_node, corrector); end - def hash_without_braces?(node); end - def message(node); end - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantSelf < RuboCop::Cop::Base - def add_lhs_to_local_variables_scopes(rhs, lhs); end - def add_masgn_lhs_variables(rhs, lhs); end - def add_match_var_scopes(in_pattern_node); end - def add_scope(node, local_variables = nil); end - def allow_self(node); end - def allowed_send_node?(node); end - def initialize(config = nil, options = nil); end - def on_and_asgn(node); end - def on_args(node); end - def on_argument(node); end - def on_block(node); end - def on_blockarg(node); end - def on_def(node); end - def on_defs(node); end - def on_if(node); end - def on_in_pattern(node); end - def on_lvasgn(node); end - def on_masgn(node); end - def on_op_asgn(node); end - def on_or_asgn(node); end - def on_send(node); end - def on_until(node); end - def on_while(node); end - def regular_method_call?(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::RedundantSort < RuboCop::Cop::Base - def accessor_start(node); end - def arg_node(node); end - def arg_value(node); end - def base(accessor, arg); end - def find_redundant_sort(*nodes); end - def message(node, sorter, accessor); end - def offense_range(sort_node, node); end - def on_send(node); end - def redundant_sort?(param0 = nil); end - def register_offense(node, sort_node, sorter, accessor); end - def suffix(sorter); end - def suggestion(sorter, accessor, arg); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RedundantSortBy < RuboCop::Cop::Base - def on_block(node); end - def redundant_sort_by(param0 = nil); end - def sort_by_range(send, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RegexpLiteral < RuboCop::Cop::Base - def allow_inner_slashes?; end - def allowed_mixed_percent_r?(node); end - def allowed_mixed_slash?(node); end - def allowed_omit_parentheses_with_percent_r_literal?(node); end - def allowed_percent_r_literal?(node); end - def allowed_slash_literal?(node); end - def calculate_replacement(node); end - def contains_disallowed_slash?(node); end - def contains_slash?(node); end - def correct_delimiters(node, corrector); end - def correct_inner_slashes(node, corrector); end - def inner_slash_after_correction(node); end - def inner_slash_before_correction(node); end - def inner_slash_for(opening_delimiter); end - def inner_slash_indices(node); end - def node_body(node, include_begin_nodes: nil); end - def on_regexp(node); end - def preferred_delimiters; end - def slash_literal?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::RescueModifier < RuboCop::Cop::Base - def correct_rescue_block(corrector, node, parenthesized); end - def indentation_and_offset(node, parenthesized); end - def on_resbody(node); end - def parenthesized?(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Style::RescueStandardError < RuboCop::Cop::Base - def offense_for_explicit_enforced_style(node); end - def offense_for_implicit_enforced_style(node, error); end - def on_resbody(node); end - def rescue_standard_error?(param0 = nil); end - def rescue_without_error_class?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::RescueNode -end -class RuboCop::Cop::Style::ReturnNil < RuboCop::Cop::Base - def chained_send?(param0 = nil); end - def correct_style?(node); end - def define_method?(param0 = nil); end - def message(_node); end - def on_return(node); end - def return_nil_node?(param0 = nil); end - def return_node?(param0 = nil); end - def scoped_node?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::SafeNavigation < RuboCop::Cop::Base - def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end - def allowed_if_condition?(node); end - def autocorrect(corrector, node); end - def begin_range(node, method_call); end - def chain_length(method_chain, method); end - def check_node(node); end - def comments(node); end - def end_range(node, method_call); end - def extract_common_parts(method_chain, checked_variable); end - def extract_parts(node); end - def extract_parts_from_and(node); end - def extract_parts_from_if(node); end - def find_matching_receiver_invocation(method_chain, checked_variable); end - def handle_comments(corrector, node, method_call); end - def max_chain_length; end - def method_call(node); end - def method_called?(send_node); end - def modifier_if_safe_navigation_candidate(param0 = nil); end - def negated?(send_node); end - def not_nil_check?(param0 = nil); end - def on_and(node); end - def on_if(node); end - def relevant_comment_ranges(node); end - def unsafe_method?(send_node); end - def unsafe_method_used?(method_chain, method); end - def use_var_only_in_unless_modifier?(node, variable); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::NilMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::Sample < RuboCop::Cop::Base - def correction(shuffle_arg, method, method_args); end - def extract_source(args); end - def message(shuffle_arg, method, method_args, range); end - def offensive?(method, method_args); end - def on_send(node); end - def range_size(range_node); end - def sample_arg(method, method_args); end - def sample_candidate?(param0 = nil); end - def sample_size(method_args); end - def sample_size_for_one_arg(arg); end - def sample_size_for_two_args(first, second); end - def source_range(shuffle_node, node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::SelectByRegexp < RuboCop::Cop::Base - def calls_lvar?(param0 = nil, param1); end - def creates_hash?(param0 = nil); end - def env_const?(param0 = nil); end - def extract_send_node(block_node); end - def find_regexp(node, block); end - def match_predicate_without_receiver?(node); end - def on_send(node); end - def receiver_allowed?(node); end - def regexp_match?(param0 = nil); end - def register_offense(node, block_node, regexp); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::SelfAssignment < RuboCop::Cop::Base - def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end - def autocorrect(corrector, node); end - def autocorrect_boolean_node(corrector, node, rhs); end - def autocorrect_send_node(corrector, node, rhs); end - def check(node, var_type); end - def check_boolean_node(node, rhs, var_name, var_type); end - def check_send_node(node, rhs, var_name, var_type); end - def on_cvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::Semicolon < RuboCop::Cop::Base - def check_for_line_terminator_or_opener; end - def each_semicolon; end - def expressions_per_line(exprs); end - def find_semicolon_positions(line); end - def on_begin(node); end - def on_new_investigation; end - def register_semicolon(line, column, after_expression); end - def self.autocorrect_incompatible_with; end - def tokens_for_lines; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::Send < RuboCop::Cop::Base - def on_csend(node); end - def on_send(node); end -end -class RuboCop::Cop::Style::SignalException < RuboCop::Cop::Base - def allow(method_name, node); end - def autocorrect(corrector, node); end - def check_scope(method_name, node); end - def check_send(method_name, node); end - def command_or_kernel_call?(name, node); end - def custom_fail_methods(param0); end - def each_command_or_kernel_call(method_name, node); end - def kernel_call?(param0 = nil, param1); end - def message(method_name); end - def on_new_investigation; end - def on_rescue(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::SingleArgumentDig < RuboCop::Cop::Base - def on_send(node); end - def single_argument_dig?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::SingleLineBlockParams < RuboCop::Cop::Base - def args_match?(method_name, args); end - def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end - def build_preferred_arguments_map(node, preferred_arguments); end - def eligible_arguments?(node); end - def eligible_method?(node); end - def method_name(method); end - def method_names; end - def methods; end - def on_block(node); end - def target_args(method_name); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::SingleLineMethods < RuboCop::Cop::Base - def allow_empty?; end - def autocorrect(corrector, node); end - def break_line_before(corrector, node, range, indent_steps: nil); end - def correct_to_endless(corrector, node); end - def correct_to_endless?(body_node); end - def correct_to_multiline(corrector, node); end - def disallow_endless_method_style?; end - def each_part(body); end - def method_body_source(method_body); end - def move_comment(node, corrector); end - def on_def(node); end - def on_defs(node); end - def require_parentheses?(method_body); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment -end -class RuboCop::Cop::Style::SlicingWithRange < RuboCop::Cop::Base - def on_send(node); end - def range_till_minus_one?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Style::SpecialGlobalVars < RuboCop::Cop::Base - def add_require_english?; end - def autocorrect(corrector, node, global_var); end - def english_name_replacement(preferred_name, node); end - def format_english_message(global_var); end - def format_list(items); end - def format_message(english, regular, global); end - def matching_styles(global); end - def message(global_var); end - def on_gvar(node); end - def on_new_investigation; end - def preferred_names(global); end - def replacement(node, global_var); end - def should_require_english?(global_var); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::RequireLibrary -end -class RuboCop::Cop::Style::StabbyLambdaParentheses < RuboCop::Cop::Base - def message(_node); end - def missing_parentheses?(node); end - def missing_parentheses_corrector(corrector, node); end - def on_send(node); end - def parentheses?(node); end - def redundant_parentheses?(node); end - def stabby_lambda_with_args?(node); end - def unwanted_parentheses_corrector(corrector, node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::StderrPuts < RuboCop::Cop::Base - def message(node); end - def on_send(node); end - def stderr_gvar?(sym); end - def stderr_puts?(param0 = nil); end - def stderr_puts_range(send); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::StringChars < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::StringConcatenation < RuboCop::Cop::Base - def collect_parts(node, parts = nil); end - def corrected_ancestor?(node); end - def find_topmost_plus_node(node); end - def handle_quotes(parts); end - def heredoc?(node); end - def line_end_concatenation?(node); end - def mode; end - def on_new_investigation; end - def on_send(node); end - def plus_node?(node); end - def register_offense(topmost_plus_node, parts); end - def replacement(parts); end - def single_quoted?(str_node); end - def string_concatenation?(param0 = nil); end - def uncorrectable?(part); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::Util -end -class RuboCop::Cop::Style::StringHashKeys < RuboCop::Cop::Base - def on_pair(node); end - def receive_environments_method?(param0 = nil); end - def string_hash_key?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::StringLiterals < RuboCop::Cop::Base - def accept_child_double_quotes?(nodes); end - def all_string_literals?(nodes); end - def autocorrect(corrector, node); end - def check_multiline_quote_style(node, quote); end - def consistent_multiline?; end - def detect_quote_styles(node); end - def message(_node); end - def offense?(node); end - def on_dstr(node); end - def register_offense(node, message: nil); end - def unexpected_double_quotes?(quote); end - def unexpected_single_quotes?(quote); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::StringHelp - include RuboCop::Cop::StringLiteralsHelp -end -class RuboCop::Cop::Style::StringLiteralsInInterpolation < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def message(_node); end - def offense?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::StringHelp - include RuboCop::Cop::StringLiteralsHelp -end -class RuboCop::Cop::Style::StringMethods < RuboCop::Cop::Base - def on_csend(node); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::MethodPreference -end -class RuboCop::Cop::Style::Strip < RuboCop::Cop::Base - def lstrip_rstrip(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::StructInheritance < RuboCop::Cop::Base - def correct_parent(parent, corrector); end - def on_class(node); end - def range_for_empty_class_body(class_node, struct_new); end - def struct_constructor?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::SwapValues < RuboCop::Cop::Base - def allowed_assignment?(node); end - def correction_range(tmp_assign, y_assign); end - def lhs(node); end - def message(x_assign, y_assign); end - def on_asgn(node); end - def on_casgn(node); end - def on_cvasgn(node); end - def on_gvasgn(node); end - def on_ivasgn(node); end - def on_lvasgn(node); end - def replacement(x_assign); end - def rhs(node); end - def simple_assignment?(node); end - def swapping_values?(tmp_assign, x_assign, y_assign); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::SymbolArray < RuboCop::Cop::Base - def build_bracketed_array(node); end - def on_array(node); end - def self.largest_brackets; end - def self.largest_brackets=(arg0); end - def symbol_without_quote?(string); end - def symbols_contain_spaces?(node); end - def to_symbol_literal(string); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion - include RuboCop::Cop::ArrayMinSize - include RuboCop::Cop::ArraySyntax - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::PercentArray -end -class RuboCop::Cop::Style::SymbolLiteral < RuboCop::Cop::Base - def on_sym(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::SymbolProc < RuboCop::Cop::Base - def allow_comments?; end - def allow_if_method_has_argument?(send_node); end - def autocorrect(corrector, node); end - def autocorrect_with_args(corrector, node, args, method_name); end - def autocorrect_without_args(corrector, node); end - def begin_pos_for_replacement(node); end - def block_range_with_space(node); end - def destructuring_block_argument?(argument_node); end - def on_block(node); end - def on_numblock(node); end - def proc_node?(param0 = nil); end - def register_offense(node, method_name, block_method_name); end - def self.autocorrect_incompatible_with; end - def symbol_proc?(param0 = nil); end - def symbol_proc_receiver?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::IgnoredMethods::Config - include RuboCop::Cop::CommentsHelp - include RuboCop::Cop::IgnoredMethods - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::TernaryParentheses < RuboCop::Cop::Base - def autocorrect(corrector, node); end - def below_ternary_precedence?(child); end - def complex_condition?(condition); end - def condition_as_parenthesized_one_line_pattern_matching?(condition); end - def correct_parenthesized(corrector, condition); end - def correct_unparenthesized(corrector, condition); end - def infinite_loop?; end - def message(node); end - def method_name(param0 = nil); end - def non_complex_expression?(condition); end - def non_complex_send?(node); end - def offense?(node); end - def on_if(node); end - def only_closing_parenthesis_is_last_line?(condition); end - def parenthesized?(node); end - def redundant_parentheses_enabled?; end - def require_parentheses?; end - def require_parentheses_when_complex?; end - def unparenthesized_method_call?(child); end - def unsafe_autocorrect?(condition); end - def whitespace_after?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::SafeAssignment - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Style::TopLevelMethodDefinition < RuboCop::Cop::Base - def define_method_block?(param0 = nil); end - def on_block(node); end - def on_def(node); end - def on_defs(node); end - def on_send(node); end - def top_level_method_definition?(node); end -end -class RuboCop::Cop::Style::TrailingBodyOnClass < RuboCop::Cop::Base - def on_class(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::TrailingBody -end -class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < RuboCop::Cop::Base - def on_def(node); end - def on_defs(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::TrailingBody -end -class RuboCop::Cop::Style::TrailingBodyOnModule < RuboCop::Cop::Base - def on_module(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Alignment - include RuboCop::Cop::TrailingBody -end -class RuboCop::Cop::Style::TrailingCommaInArguments < RuboCop::Cop::Base - def on_csend(node); end - def on_send(node); end - def self.autocorrect_incompatible_with; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::TrailingComma -end -class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < RuboCop::Cop::Base - def on_array(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::TrailingComma -end -class RuboCop::Cop::Style::TrailingCommaInBlockArgs < RuboCop::Cop::Base - def arg_count(node); end - def argument_tokens(node); end - def last_comma(node); end - def on_block(node); end - def trailing_comma?(node); end - def useless_trailing_comma?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::TrailingCommaInHashLiteral < RuboCop::Cop::Base - def on_hash(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::TrailingComma -end -class RuboCop::Cop::Style::TrailingMethodEndStatement < RuboCop::Cop::Base - def body_and_end_on_same_line?(node); end - def on_def(node); end - def trailing_end?(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::TrailingUnderscoreVariable < RuboCop::Cop::Base - def allow_named_underscore_variables; end - def children_offenses(variables); end - def find_first_offense(variables); end - def find_first_possible_offense(variables); end - def main_node_offense(node); end - def on_masgn(node); end - def range_for_parentheses(offense, left); end - def reverse_index(collection, item); end - def splat_variable_before?(first_offense, variables); end - def unneeded_ranges(node); end - def unused_range(node_type, mlhs_node, right); end - def unused_variables_only?(offense, variables); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp - include RuboCop::Cop::SurroundingSpace -end -class RuboCop::Cop::Style::TrivialAccessors < RuboCop::Cop::Base - def accessor(kind, method_name); end - def allow_dsl_writers?; end - def allow_predicates?; end - def allowed_method_name?(node); end - def allowed_method_names; end - def allowed_reader?(node); end - def allowed_writer?(node); end - def autocorrect(corrector, node); end - def autocorrect_class(corrector, node); end - def autocorrect_instance(corrector, node); end - def dsl_writer?(node); end - def exact_name_match?; end - def ignore_class_methods?; end - def in_module_or_instance_eval?(node); end - def looks_like_trivial_reader?(node); end - def looks_like_trivial_writer?(param0 = nil); end - def names_match?(node); end - def on_def(node); end - def on_defs(node); end - def on_method_def(node); end - def top_level_node?(node); end - def trivial_accessor_kind(node); end - def trivial_reader?(node); end - def trivial_writer?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::AllowedMethods -end -class RuboCop::Cop::Style::UnlessElse < RuboCop::Cop::Base - def on_if(node); end - def range_between_condition_and_else(node, condition); end - def range_between_else_and_end(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::UnlessLogicalOperators < RuboCop::Cop::Base - def and_with_or?(param0 = nil); end - def logical_operator?(param0 = nil); end - def mixed_logical_operator?(node); end - def mixed_precedence_and?(node); end - def mixed_precedence_or?(node); end - def on_if(node); end - def or_with_and?(param0 = nil); end - include RuboCop::Cop::ConfigurableEnforcedStyle -end -class RuboCop::Cop::Style::UnpackFirst < RuboCop::Cop::Base - def first_element_range(node, unpack_call); end - def on_send(node); end - def unpack_and_first_element?(param0 = nil); end - extend RuboCop::Cop::AutoCorrector - extend RuboCop::Cop::TargetRubyVersion -end -class RuboCop::Cop::Style::VariableInterpolation < RuboCop::Cop::Base - def message(range); end - def on_node_with_interpolations(node); end - def var_nodes(nodes); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::Interpolation -end -class RuboCop::Cop::Style::WhenThen < RuboCop::Cop::Base - def on_when(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::WhileUntilDo < RuboCop::Cop::Base - def on_until(node); end - def on_while(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Style::WhileUntilModifier < RuboCop::Cop::Base - def on_until(node); end - def on_while(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::StatementModifier -end -class RuboCop::Cop::Style::WordArray < RuboCop::Cop::Base - def build_bracketed_array(node); end - def complex_content?(strings, complex_regex: nil); end - def invalid_percent_array_contents?(node); end - def on_array(node); end - def self.largest_brackets; end - def self.largest_brackets=(arg0); end - def word_regex; end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ArrayMinSize - include RuboCop::Cop::ArraySyntax - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::PercentArray -end -class RuboCop::Cop::Style::YodaCondition < RuboCop::Cop::Base - def actual_code_range(node); end - def corrected_code(node); end - def enforce_yoda?; end - def equality_only?; end - def file_constant_equal_program_name?(param0 = nil); end - def interpolation?(node); end - def message(node); end - def non_equality_operator?(node); end - def noncommutative_operator?(node); end - def on_send(node); end - def program_name?(name); end - def reverse_comparison(operator); end - def source_file_path_constant?(node); end - def valid_yoda?(node); end - def yoda_compatible_condition?(node); end - extend RuboCop::Cop::AutoCorrector - include RuboCop::Cop::ConfigurableEnforcedStyle - include RuboCop::Cop::RangeHelp -end -class RuboCop::Cop::Style::ZeroLengthPredicate < RuboCop::Cop::Base - def check_nonzero_length_predicate(node); end - def check_zero_length_predicate(node); end - def non_polymorphic_collection?(param0 = nil); end - def nonzero_length_predicate(param0 = nil); end - def on_send(node); end - def other_receiver(param0 = nil); end - def replacement(node); end - def zero_length_predicate(param0 = nil); end - def zero_length_receiver(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -module RuboCop::Cop::Security -end -class RuboCop::Cop::Security::CompoundHash < RuboCop::Cop::Base - def bad_hash_combinator?(param0 = nil); end - def contained_in_hash_method?(node, &block); end - def dynamic_hash_method_definition?(param0 = nil); end - def hash_method_definition?(param0 = nil); end - def monuple_hash?(param0 = nil); end - def on_op_asgn(node); end - def on_send(node); end - def outer_bad_hash_combinator?(node); end - def redundant_hash?(param0 = nil); end - def static_hash_method_definition?(param0 = nil); end -end -class RuboCop::Cop::Security::Eval < RuboCop::Cop::Base - def eval?(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Security::IoMethods < RuboCop::Cop::Base - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Security::JSONLoad < RuboCop::Cop::Base - def json_load(param0 = nil); end - def on_send(node); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Security::MarshalLoad < RuboCop::Cop::Base - def marshal_load(param0 = nil); end - def on_send(node); end -end -class RuboCop::Cop::Security::Open < RuboCop::Cop::Base - def composite_string?(node); end - def concatenated_string?(node); end - def interpolated_string?(node); end - def on_send(node); end - def open?(param0 = nil); end - def safe?(node); end - def safe_argument?(argument); end - def simple_string?(node); end -end -class RuboCop::Cop::Security::YAMLLoad < RuboCop::Cop::Base - def on_send(node); end - def yaml_load(param0 = nil); end - extend RuboCop::Cop::AutoCorrector -end -class RuboCop::Cop::Team - def autocorrect(processed_source, report); end - def autocorrect?; end - def autocorrect_report(report); end - def be_ready; end - def collate_corrections(report); end - def cops; end - def debug?; end - def each_corrector(report); end - def errors; end - def external_dependency_checksum; end - def forces; end - def handle_error(error, location, cop); end - def handle_warning(error, location); end - def initialize(cops, config = nil, options = nil); end - def inspect_file(processed_source); end - def investigate(processed_source); end - def investigate_partial(cops, processed_source); end - def process_errors(file, errors); end - def reset; end - def roundup_relevant_cops(filename); end - def self.forces_for(cops); end - def self.mobilize(cop_classes, config, options = nil); end - def self.mobilize_cops(cop_classes, config, options = nil); end - def self.new(cop_or_classes, config, options = nil); end - def support_target_rails_version?(cop); end - def support_target_ruby_version?(cop); end - def suppress_clobbering; end - def updated_source_file; end - def updated_source_file?; end - def validate_config; end - def warnings; end -end -module RuboCop::Formatter -end -module RuboCop::Formatter::TextUtil - def pluralize(number, thing, options = nil); end - def self.pluralize(number, thing, options = nil); end -end -class RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def file_started(file, options); end - def finished(inspected_files); end - def initialize(output, options = nil); end - def options; end - def output; end - def started(target_files); end -end -module RuboCop::Formatter::Colorizable - def black(string); end - def blue(string); end - def colorize(string, *args); end - def cyan(string); end - def green(string); end - def magenta(string); end - def rainbow; end - def red(string); end - def white(string); end - def yellow(string); end -end -class RuboCop::Formatter::SimpleTextFormatter < RuboCop::Formatter::BaseFormatter - def annotate_message(msg); end - def colored_severity_code(offense); end - def count_stats(offenses); end - def file_finished(file, offenses); end - def finished(inspected_files); end - def message(offense); end - def report_file(file, offenses); end - def report_summary(file_count, offense_count, correction_count, correctable_count); end - def started(_target_files); end - include RuboCop::Formatter::Colorizable - include RuboCop::PathUtil -end -class RuboCop::Formatter::SimpleTextFormatter::Report - def correctable; end - def corrections; end - def files; end - def initialize(file_count, offense_count, correction_count, correctable_count, rainbow, safe_autocorrect: nil); end - def offenses; end - def rainbow; end - def summary; end - include RuboCop::Formatter::Colorizable - include RuboCop::Formatter::TextUtil -end -class RuboCop::Formatter::ClangStyleFormatter < RuboCop::Formatter::SimpleTextFormatter - def report_file(file, offenses); end - def report_highlighted_area(highlighted_area); end - def report_line(location); end - def report_offense(file, offense); end - def valid_line?(offense); end -end -class RuboCop::Formatter::DisabledConfigFormatter < RuboCop::Formatter::BaseFormatter - def command; end - def cop_config_params(default_cfg, cfg); end - def default_config(cop_name); end - def excludes(offending_files, cop_name, parent); end - def file_finished(file, offenses); end - def file_started(_file, _file_info); end - def finished(_inspected_files); end - def initialize(output, options = nil); end - def merge_mode_for_exclude?(cfg); end - def output_cop(cop_name, offense_count); end - def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end - def output_cop_config(output_buffer, cfg, cop_name); end - def output_cop_param_comments(output_buffer, params, default_cfg); end - def output_exclude_list(output_buffer, offending_files, cop_name); end - def output_exclude_path(output_buffer, exclude_path, parent); end - def output_offending_files(output_buffer, cfg, cop_name); end - def output_offenses; end - def safe_autocorrect?(config); end - def self.config_to_allow_offenses; end - def self.config_to_allow_offenses=(arg0); end - def self.detected_styles; end - def self.detected_styles=(arg0); end - def set_max(cfg, cop_name); end - def show_offense_counts?; end - def show_timestamp?; end - def supports_safe_autocorrect?(cop_class, default_cfg); end - def supports_unsafe_autocorrect?(cop_class, default_cfg); end - def timestamp; end - include RuboCop::PathUtil -end -class RuboCop::Formatter::EmacsStyleFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def message(offense); end -end -class RuboCop::Formatter::FileListFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end -end -class RuboCop::Formatter::FuubarStyleFormatter < RuboCop::Formatter::ClangStyleFormatter - def count_stats(offenses); end - def file_finished(file, offenses); end - def initialize(*output); end - def progressbar_color; end - def started(target_files); end - def with_color; end -end -class RuboCop::Formatter::GitHubActionsFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def finished(_inspected_files); end - def github_escape(string); end - def github_severity(offense); end - def minimum_severity_to_fail; end - def report_offense(file, offense); end - def started(_target_files); end -end -class RuboCop::Formatter::HTMLFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def files; end - def finished(inspected_files); end - def initialize(output, options = nil); end - def render_html; end - def started(target_files); end - def summary; end -end -class RuboCop::Formatter::HTMLFormatter::Color < Struct - def alpha; end - def alpha=(_); end - def blue; end - def blue=(_); end - def fade_out(amount); end - def green; end - def green=(_); end - def red; end - def red=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def to_s; end -end -class RuboCop::Formatter::HTMLFormatter::Summary < Struct - def inspected_files; end - def inspected_files=(_); end - def offense_count; end - def offense_count=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def target_files; end - def target_files=(_); end -end -class RuboCop::Formatter::HTMLFormatter::FileOffenses < Struct - def offenses; end - def offenses=(_); end - def path; end - def path=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RuboCop::Formatter::HTMLFormatter::ERBContext - def base64_encoded_logo_image; end - def binding; end - def decorated_message(offense); end - def escape(string); end - def files; end - def highlighted_source_line(offense); end - def hightlight_source_tag(offense); end - def initialize(files, summary); end - def possible_ellipses(location); end - def source_after_highlight(offense); end - def source_before_highlight(offense); end - def summary; end - include RuboCop::Formatter::TextUtil - include RuboCop::PathUtil -end -class RuboCop::Formatter::JSONFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def finished(inspected_files); end - def hash_for_file(file, offenses); end - def hash_for_location(offense); end - def hash_for_offense(offense); end - def initialize(output, options = nil); end - def metadata_hash; end - def output_hash; end - def started(target_files); end - include RuboCop::PathUtil -end -class RuboCop::Formatter::JUnitFormatter < RuboCop::Formatter::BaseFormatter - def add_failure_to(testcase, offenses, cop_name); end - def add_testcase_element_to_testsuite_element(file, target_offenses, cop); end - def classname_attribute_value(file); end - def file_finished(file, offenses); end - def finished(_inspected_files); end - def initialize(output, options = nil); end - def offenses_for_cop(all_offenses, cop); end - def relevant_for_output?(options, target_offenses); end - def reset_count; end -end -class RuboCop::Formatter::MarkdownFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def files; end - def finished(inspected_files); end - def initialize(output, options = nil); end - def possible_ellipses(location); end - def render_markdown; end - def started(target_files); end - def summary; end - def write_code(offense); end - def write_context(offense); end - def write_file_messages; end - def write_heading(file); end - include RuboCop::Formatter::TextUtil - include RuboCop::PathUtil -end -class RuboCop::Formatter::OffenseCountFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(_file, offenses); end - def finished(_inspected_files); end - def offense_counts; end - def ordered_offense_counts(offense_counts); end - def report_summary(offense_counts); end - def started(target_files); end - def total_offense_count(offense_counts); end -end -class RuboCop::Formatter::ProgressFormatter < RuboCop::Formatter::ClangStyleFormatter - def file_finished(file, offenses); end - def finished(inspected_files); end - def initialize(output, options = nil); end - def report_file_as_mark(offenses); end - def started(target_files); end - include RuboCop::Formatter::TextUtil -end -class RuboCop::Formatter::QuietFormatter < RuboCop::Formatter::SimpleTextFormatter - def report_summary(file_count, offense_count, correction_count, correctable_count); end -end -class RuboCop::Formatter::TapFormatter < RuboCop::Formatter::ClangStyleFormatter - def annotate_message(msg); end - def file_finished(file, offenses); end - def message(offense); end - def report_highlighted_area(highlighted_area); end - def report_line(location); end - def report_offense(file, offense); end - def started(target_files); end -end -class RuboCop::Formatter::WorstOffendersFormatter < RuboCop::Formatter::BaseFormatter - def file_finished(file, offenses); end - def finished(_inspected_files); end - def offense_counts; end - def ordered_offense_counts(offense_counts); end - def report_summary(offense_counts); end - def started(target_files); end - def total_offense_count(offense_counts); end -end -class RuboCop::Formatter::PacmanFormatter < RuboCop::Formatter::ClangStyleFormatter - def cols; end - def file_finished(file, offenses); end - def file_started(_file, _options); end - def initialize(output, options = nil); end - def next_step(offenses); end - def pacdots(number); end - def progress_line; end - def progress_line=(arg0); end - def started(target_files); end - def step(character); end - def update_progress_line; end - include RuboCop::Formatter::TextUtil -end -class RuboCop::Formatter::AutoGenConfigFormatter < RuboCop::Formatter::ProgressFormatter - def finished(inspected_files); end -end -class RuboCop::Formatter::FormatterSet < Array - def add_formatter(formatter_type, output_path = nil); end - def builtin_formatter_class(specified_key); end - def close_output_files; end - def custom_formatter_class(specified_class_name); end - def file_finished(file, offenses); end - def file_started(file, options); end - def finished(*args); end - def formatter_class(formatter_type); end - def initialize(options = nil); end - def started(*args); end -end -class RuboCop::CachedData - def deserialize_offenses(offenses); end - def from_json(text); end - def initialize(filename); end - def message(offense); end - def serialize_offense(offense); end - def to_json(offenses); end -end -class RuboCop::Config - def [](*args, &block); end - def []=(*args, &block); end - def active_support_extensions_enabled?; end - def add_excludes_from_higher_level(highest_config); end - def allowed_camel_case_file?(file); end - def base_dir_for_path_parameters; end - def bundler_lock_file_path; end - def check; end - def delete(*args, &block); end - def department_of(qualified_cop_name); end - def deprecation_check; end - def dig(*args, &block); end - def disabled_new_cops?; end - def each(*args, &block); end - def each_key(*args, &block); end - def enable_cop?(qualified_cop_name, cop_options); end - def enabled_new_cops?; end - def fetch(*args, &block); end - def file_to_exclude?(file); end - def file_to_include?(file); end - def for_all_cops; end - def for_badge(badge); end - def for_cop(cop); end - def for_department(department_name); end - def initialize(hash = nil, loaded_path = nil); end - def internal?; end - def key?(*args, &block); end - def keys(*args, &block); end - def loaded_features; end - def loaded_path; end - def make_excludes_absolute; end - def map(*args, &block); end - def merge(*args, &block); end - def path_relative_to_config(path); end - def patterns_to_exclude; end - def patterns_to_include; end - def pending_cops; end - def possibly_include_hidden?; end - def read_rails_version_from_bundler_lock_file; end - def replace(*args, &block); end - def self.create(hash, path, check: nil); end - def signature; end - def smart_loaded_path; end - def target_rails_version; end - def target_rails_version_from_bundler_lock_file; end - def target_ruby_version(*args, &block); end - def to_h(*args, &block); end - def to_hash(*args, &block); end - def to_s; end - def transform_values(*args, &block); end - def validate(*args, &block); end - def validate_after_resolution; end - extend Forwardable - include RuboCop::FileFinder - include RuboCop::PathUtil -end -class RuboCop::Config::CopConfig < Struct - def metadata; end - def metadata=(_); end - def name; end - def name=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end -end -class RuboCop::ConfigLoaderResolver - def base_configs(path, inherit_from, file); end - def determine_inherit_mode(hash, key); end - def disabled?(hash, department); end - def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end - def fix_include_paths(base_config_path, hash, path, key, value); end - def gem_config_path(gem_name, relative_config_path); end - def handle_disabled_by_default(config, new_default_configuration); end - def inherited_file(path, inherit_from, file); end - def merge(base_hash, derived_hash, **opts); end - def merge_hashes?(base_hash, derived_hash, key); end - def merge_with_default(config, config_file, unset_nil:); end - def override_department_setting_for_cops(base_hash, derived_hash); end - def override_enabled_for_disabled_departments(base_hash, derived_hash); end - def remote_file?(uri); end - def resolve_inheritance(path, hash, file, debug); end - def resolve_inheritance_from_gems(hash); end - def resolve_requires(path, hash); end - def should_merge?(mode, key); end - def should_override?(mode, key); end - def should_union?(derived_hash, base_hash, root_mode, key); end - def transform(config, &block); end - def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end -end -class RuboCop::ConfigNotFoundError < RuboCop::Error -end -class RuboCop::ConfigLoader - def self.add_excludes_from_files(config, config_file); end - def self.add_loaded_features(loaded_features); end - def self.add_missing_namespaces(path, hash); end - def self.check_duplication(yaml_code, absolute_path); end - def self.clear_options; end - def self.configuration_file_for(target_dir); end - def self.configuration_from_file(config_file, check: nil); end - def self.debug; end - def self.debug=(arg0); end - def self.debug?; end - def self.default_configuration; end - def self.default_configuration=(arg0); end - def self.disable_pending_cops; end - def self.disable_pending_cops=(arg0); end - def self.enable_pending_cops; end - def self.enable_pending_cops=(arg0); end - def self.expand_path(path); end - def self.file_path(file); end - def self.find_project_dotfile(target_dir); end - def self.find_project_root; end - def self.find_user_dotfile; end - def self.find_user_xdg_config; end - def self.ignore_parent_exclusion; end - def self.ignore_parent_exclusion=(arg0); end - def self.ignore_parent_exclusion?; end - def self.ignore_unrecognized_cops; end - def self.ignore_unrecognized_cops=(arg0); end - def self.load_file(file, check: nil); end - def self.load_yaml_configuration(absolute_path); end - def self.loaded_features; end - def self.merge(base_hash, derived_hash); end - def self.merge_with_default(config, config_file, unset_nil: nil); end - def self.possible_new_cops?(config); end - def self.project_root; end - def self.project_root=(arg0); end - def self.read_file(absolute_path); end - def self.resolver; end - def self.warn_on_pending_cops(pending_cops); end - def self.warn_pending_cop(cop); end - def self.yaml_safe_load!(yaml_code, filename); end - def self.yaml_safe_load(yaml_code, filename); end -end -class RuboCop::ConfigObsoletion - def initialize(config); end - def load_cop_rules(rules); end - def load_parameter_rules(rules); end - def load_rules; end - def obsoletions; end - def reject_obsolete!; end - def rules; end - def self.files; end - def self.files=(arg0); end - def self.legacy_cop_names; end - def warnings; end -end -class RuboCop::ConfigObsoletion::Rule - def config; end - def cop_rule?; end - def initialize(config); end - def parameter_rule?; end - def smart_loaded_path; end - def to_sentence(collection, connector: nil); end - def violated?; end -end -class RuboCop::ConfigObsoletion::CopRule < RuboCop::ConfigObsoletion::Rule - def cop_rule?; end - def initialize(config, old_name); end - def message; end - def old_name; end - def violated?; end - def warning?; end -end -class RuboCop::ConfigObsoletion::ParameterRule < RuboCop::ConfigObsoletion::Rule - def alternative; end - def cop; end - def initialize(config, cop, parameter, metadata); end - def metadata; end - def parameter; end - def parameter_rule?; end - def reason; end - def severity; end - def violated?; end - def warning?; end -end -class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < RuboCop::ConfigObsoletion::ParameterRule - def message; end - def value; end - def violated?; end -end -class RuboCop::ConfigObsoletion::ChangedParameter < RuboCop::ConfigObsoletion::ParameterRule - def message; end -end -class RuboCop::ConfigObsoletion::ExtractedCop < RuboCop::ConfigObsoletion::CopRule - def affected_cops; end - def department; end - def feature_loaded?; end - def gem; end - def initialize(config, old_name, gem); end - def rule_message; end - def violated?; end -end -class RuboCop::ConfigObsoletion::RemovedCop < RuboCop::ConfigObsoletion::CopRule - def alternatives; end - def initialize(config, old_name, metadata); end - def metadata; end - def old_name; end - def reason; end - def rule_message; end -end -class RuboCop::ConfigObsoletion::RenamedCop < RuboCop::ConfigObsoletion::CopRule - def initialize(config, old_name, new_name); end - def moved?; end - def new_name; end - def rule_message; end - def verb; end -end -class RuboCop::ConfigObsoletion::SplitCop < RuboCop::ConfigObsoletion::CopRule - def alternatives; end - def initialize(config, old_name, metadata); end - def metadata; end - def rule_message; end -end -class RuboCop::ConfigStore - def for(file_or_dir); end - def for_dir(dir); end - def for_file(file); end - def for_pwd; end - def force_default_config!; end - def initialize; end - def options_config=(options_config); end - def unvalidated; end - def validated; end - def validated?; end -end -class RuboCop::ConfigValidator - def alert_about_unrecognized_cops(invalid_cop_names); end - def check_cop_config_value(hash, parent = nil); end - def check_obsoletions; end - def check_target_ruby; end - def each_invalid_parameter(cop_name); end - def for_all_cops(*args, &block); end - def initialize(config); end - def list_unknown_cops(invalid_cop_names); end - def msg_not_boolean(parent, key, value); end - def reject_conflicting_safe_settings; end - def reject_mutually_exclusive_defaults; end - def smart_loaded_path(*args, &block); end - def suggestion(name); end - def target_ruby; end - def target_ruby_version; end - def validate; end - def validate_after_resolution; end - def validate_enforced_styles(valid_cop_names); end - def validate_new_cops_parameter; end - def validate_parameter_names(valid_cop_names); end - def validate_section_presence(name); end - def validate_support_and_has_list(name, formats, valid); end - def validate_syntax_cop; end - extend Forwardable -end -class RuboCop::Lockfile - def dependencies; end - def gems; end - def includes_gem?(name); end - def parser; end -end -class RuboCop::TargetFinder - def all_cops_include; end - def combined_exclude_glob_patterns(base_dir); end - def configured_include?(file); end - def debug?; end - def fail_fast?; end - def find(args, mode); end - def find_files(base_dir, flags); end - def force_exclusion?; end - def included_file?(file); end - def initialize(config_store, options = nil); end - def order; end - def process_explicit_path(path, mode); end - def ruby_executable?(file); end - def ruby_extension?(file); end - def ruby_extensions; end - def ruby_file?(file); end - def ruby_filename?(file); end - def ruby_filenames; end - def ruby_interpreters(file); end - def stdin?; end - def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags); end - def target_files_in_dir(base_dir = nil); end - def to_inspect?(file, hidden_files, base_dir_config); end - def wanted_dir_patterns(base_dir, exclude_pattern, flags); end -end -class RuboCop::DirectiveComment - def all_cop_names; end - def all_cops?; end - def comment; end - def cop_names; end - def cop_names_for_department(department); end - def cop_registry; end - def cops; end - def department?(name); end - def department_names; end - def directive_count; end - def disabled?; end - def disabled_all?; end - def enabled?; end - def enabled_all?; end - def exclude_redundant_directive_cop(cops); end - def in_directive_department?(cop); end - def initialize(comment, cop_registry = nil); end - def line_number; end - def match?(cop_names); end - def match_captures; end - def mode; end - def overridden_by_department?(cop); end - def parsed_cop_names; end - def range; end - def self.before_comment(line); end - def single_line?; end - def splitted_cops_string; end -end -class RuboCop::CommentConfig - def analyze; end - def analyze_cop(analysis, directive); end - def analyze_disabled(analysis, directive); end - def analyze_rest(analysis, directive); end - def analyze_single_line(analysis, directive); end - def comment_only_line?(line_number); end - def cop_disabled_line_ranges; end - def cop_enabled_at_line?(cop, line_number); end - def cop_line_ranges(analysis); end - def each_directive; end - def extra_enabled_comments; end - def extra_enabled_comments_with_names(extras:, names:); end - def handle_enable_all(directive, names, extras); end - def handle_switch(directive, names, extras); end - def initialize(processed_source); end - def non_comment_token_line_numbers; end - def processed_source; end - def qualified_cop_name(cop_name); end -end -class RuboCop::CommentConfig::CopAnalysis < Struct - def line_ranges; end - def line_ranges=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def start_line_number; end - def start_line_number=(_); end -end -class RuboCop::MagicComment - def any?; end - def encoding_specified?; end - def extract(pattern); end - def frozen_string_literal; end - def frozen_string_literal?; end - def frozen_string_literal_specified?; end - def initialize(comment); end - def self.parse(comment); end - def shareable_constant_value; end - def shareable_constant_value_specified?; end - def specified?(value); end - def typed; end - def typed_specified?; end - def valid?; end - def valid_literal_value?; end - def valid_shareable_constant_value?; end -end -class RuboCop::MagicComment::EditorComment < RuboCop::MagicComment - def encoding; end - def match(keyword); end - def tokens; end - def without(type); end -end -class RuboCop::MagicComment::EmacsComment < RuboCop::MagicComment::EditorComment - def extract_frozen_string_literal; end - def extract_shareable_constant_value; end - def extract_typed; end -end -class RuboCop::MagicComment::VimComment < RuboCop::MagicComment::EditorComment - def encoding; end - def extract_typed; end - def frozen_string_literal; end - def shareable_constant_value; end -end -class RuboCop::MagicComment::SimpleComment < RuboCop::MagicComment - def encoding; end - def extract_frozen_string_literal; end - def extract_shareable_constant_value; end - def extract_typed; end - def without(type); end -end -class RuboCop::ResultCache - def any_symlink?(path); end - def context_checksum(team, options); end - def debug?; end - def file_checksum(file, config_store); end - def initialize(file, team, options, config_store, cache_root = nil); end - def load; end - def path; end - def relevant_options_digest(options); end - def rubocop_checksum; end - def rubocop_extra_features; end - def save(offenses); end - def self.allow_symlinks_in_cache_location?(config_store); end - def self.cache_root(config_store); end - def self.cleanup(config_store, verbose, cache_root = nil); end - def self.inhibit_cleanup; end - def self.inhibit_cleanup=(arg0); end - def self.remove_files(files, dirs, remove_count); end - def self.remove_oldest_files(files, dirs, cache_root, verbose); end - def self.requires_file_removal?(file_count, config_store); end - def self.rubocop_required_features; end - def self.rubocop_required_features=(arg0); end - def self.source_checksum; end - def self.source_checksum=(arg0); end - def symlink_protection_triggered?(path); end - def team_checksum(team); end - def valid?; end -end -class RuboCop::Runner - def aborting=(arg0); end - def aborting?; end - def add_redundant_disables(file, offenses, source); end - def cached_result(file, team); end - def cached_run?; end - def check_for_infinite_loop(processed_source, offenses_by_iteration); end - def check_for_redundant_disables?(source); end - def considered_failure?(offense); end - def default_config(cop_name); end - def do_inspection_loop(file); end - def each_inspected_file(files); end - def errors; end - def file_finished(file, offenses); end - def file_offense_cache(file); end - def file_offenses(file); end - def file_started(file); end - def filter_cop_classes(cop_classes, config); end - def filtered_run?; end - def find_target_files(paths); end - def formatter_set; end - def get_processed_source(file); end - def initialize(options, config_store); end - def inspect_file(processed_source, team = nil); end - def inspect_files(files); end - def iterate_until_no_changes(source, offenses_by_iteration); end - def list_files(paths); end - def mark_as_safe_by_config?(config); end - def minimum_severity_to_fail; end - def mobilize_team(processed_source); end - def mobilized_cop_classes(config); end - def offenses_to_report(offenses); end - def process_file(file); end - def qualify_option_cop_names; end - def redundant_cop_disable_directive(file); end - def run(paths); end - def save_in_cache(cache, offenses); end - def standby_team(config); end - def style_guide_cops_only?(config); end - def supports_safe_autocorrect?(offense); end - def team_for_redundant_disables(file, offenses, source); end - def warm_cache(target_files); end - def warnings; end -end -class RuboCop::Runner::InfiniteCorrectionLoop < StandardError - def initialize(path, offenses_by_iteration, loop_start: nil); end - def offenses; end -end -class RuboCop::CLI - def act_on_options; end - def apply_default_formatter; end - def config_store; end - def execute_runners; end - def handle_exiting_options; end - def initialize; end - def options; end - def parallel_by_default!; end - def run(args = nil); end - def run_command(name); end - def set_options_to_config_loader; end - def suggest_extensions; end - def validate_options_vs_config; end -end -class RuboCop::CLI::Finished < StandardError -end -module RuboCop::CLI::Command - def self.class_for(name); end - def self.run(env, name); end -end -class RuboCop::CLI::Environment - def config_store; end - def initialize(options, config_store, paths); end - def options; end - def paths; end - def run(name); end -end -class RuboCop::CLI::Command::Base - def env; end - def initialize(env); end - def self.by_command_name(name); end - def self.command_name; end - def self.command_name=(arg0); end - def self.inherited(subclass); end -end -class RuboCop::CLI::Command::AutoGenerateConfig < RuboCop::CLI::Command::Base - def add_formatter; end - def add_inheritance_from_auto_generated_file(config_file); end - def execute_runner; end - def existing_configuration(config_file); end - def line_length_cop(config); end - def line_length_enabled?(config); end - def max_line_length(config); end - def maybe_run_line_length_cop; end - def options_config_in_root?; end - def relative_path_to_todo_from_options_config; end - def reset_config_and_auto_gen_file; end - def run; end - def run_all_cops(line_length_contents); end - def run_line_length_cop; end - def same_max_line_length?(config1, config2); end - def skip_line_length_cop(reason); end - def write_config_file(file_name, file_string, rubocop_yml_contents); end -end -class RuboCop::CLI::Command::ExecuteRunner < RuboCop::CLI::Command::Base - def display_error_summary(errors); end - def display_summary(runner); end - def display_warning_summary(warnings); end - def execute_runner(paths); end - def maybe_print_corrected_source; end - def run; end - def with_redirect; end - include RuboCop::Formatter::TextUtil -end -class RuboCop::CLI::Command::InitDotfile < RuboCop::CLI::Command::Base - def run; end -end -class RuboCop::CLI::Command::ShowCops < RuboCop::CLI::Command::Base - def config_lines(cop); end - def cops_of_department(cops, department); end - def initialize(env); end - def print_available_cops; end - def print_cop_details(cops); end - def print_cops_of_department(registry, department, show_all); end - def run; end - def selected_cops_of_department(cops, department); end -end -class RuboCop::CLI::Command::ShowDocsUrl < RuboCop::CLI::Command::Base - def cops_array; end - def initialize(env); end - def print_documentation_url; end - def registry_hash; end - def run; end -end -class RuboCop::CLI::Command::SuggestExtensions < RuboCop::CLI::Command::Base - def current_formatter; end - def dependent_gems; end - def extensions; end - def installed_gems; end - def lockfile; end - def puts(*args); end - def run; end - def skip?; end -end -class RuboCop::CLI::Command::Version < RuboCop::CLI::Command::Base - def run; end -end -class RuboCop::ConfigRegeneration - def generation_command; end - def options; end - def todo_exists?; end -end -class RuboCop::IncorrectCopNameError < StandardError -end -class RuboCop::OptionArgumentError < StandardError -end -class RuboCop::Options - def add_additional_modes(opts); end - def add_autocorrection_options(opts); end - def add_cache_options(opts); end - def add_check_options(opts); end - def add_config_generation_options(opts); end - def add_cop_selection_csv_option(option, opts); end - def add_general_options(opts); end - def add_output_options(opts); end - def add_server_options(opts); end - def add_severity_option(opts); end - def args_from_env; end - def args_from_file; end - def define_options; end - def handle_deprecated_option(old_option, new_option); end - def initialize; end - def long_opt_symbol(args); end - def option(opts, *args); end - def parse(command_line_args); end - def rainbow; end - def require_feature(file); end - def section(opts, heading, &_block); end -end -class RuboCop::OptionsValidator - def boolean_or_empty_cache?; end - def disable_parallel_when_invalid_option_combo; end - def display_only_fail_level_offenses_with_autocorrect?; end - def except_syntax?; end - def incompatible_options; end - def initialize(options); end - def invalid_arguments_for_parallel; end - def only_includes_redundant_disable?; end - def self.format_message_from(name, cop_names); end - def self.validate_cop_list(names); end - def validate_auto_gen_config; end - def validate_autocorrect; end - def validate_cache_enabled_for_cache_root; end - def validate_compatibility; end - def validate_cop_options; end - def validate_display_only_correctable_and_autocorrect; end - def validate_display_only_failed; end - def validate_display_only_failed_and_display_only_correctable; end - def validate_exclude_limit_option; end -end -module RuboCop::OptionsHelp -end -class RuboCop::RemoteConfig - def cache_name_from_uri; end - def cache_path; end - def cache_path_exists?; end - def cache_path_expired?; end - def cloned_url; end - def file; end - def generate_request(uri); end - def handle_response(response, limit, &block); end - def inherit_from_remote(file, path); end - def initialize(url, base_dir); end - def request(uri = nil, limit = nil, &block); end - def uri; end -end -class RuboCop::TargetRuby - def initialize(config); end - def rubocop_version_with_support; end - def self.supported_versions; end - def source; end - def supported?; end - def version; end -end -class RuboCop::TargetRuby::Source - def initialize(config); end - def name; end - def to_s; end - def version; end -end -class RuboCop::TargetRuby::RuboCopConfig < RuboCop::TargetRuby::Source - def find_version; end - def name; end -end -class RuboCop::TargetRuby::RubyVersionFile < RuboCop::TargetRuby::Source - def filename; end - def find_version; end - def name; end - def pattern; end - def version_file; end -end -class RuboCop::TargetRuby::ToolVersionsFile < RuboCop::TargetRuby::RubyVersionFile - def filename; end - def name; end - def pattern; end -end -class RuboCop::TargetRuby::BundlerLockFile < RuboCop::TargetRuby::Source - def bundler_lock_file_path; end - def find_version; end - def name; end -end -class RuboCop::TargetRuby::GemspecFile < RuboCop::TargetRuby::Source - def find_default_minimal_known_ruby(right_hand_side); end - def find_version; end - def gem_requirement?(param0 = nil); end - def gemspec_filename; end - def gemspec_filepath; end - def name; end - def required_ruby_version(param0); end - def version_from_array(array); end - def version_from_gemspec_file(file); end - def version_from_right_hand_side(right_hand_side); end - extend RuboCop::AST::NodePattern::Macros -end -class RuboCop::TargetRuby::Default < RuboCop::TargetRuby::Source - def find_version; end - def name; end -end -module RuboCop::YAMLDuplicationChecker - def self.check(yaml_string, filename, &on_duplicated); end - def self.traverse(tree, &on_duplicated); end -end diff --git a/sorbet/rbi/gems/rubocop@1.35.1.rbi b/sorbet/rbi/gems/rubocop@1.35.1.rbi new file mode 100644 index 00000000..575819ce --- /dev/null +++ b/sorbet/rbi/gems/rubocop@1.35.1.rbi @@ -0,0 +1,52230 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop` gem. +# Please instead update this file by running `bin/tapioca gem rubocop`. + +class Parser::Source::Range + include ::RuboCop::Ext::Range +end + +class Regexp::Expression::Base + include ::RuboCop::Ext::RegexpParser::Expression::Base +end + +class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression + include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet +end + +# These aliases are for compatibility. +# +# source://rubocop-1.35.1/lib/rubocop/version.rb:3 +module RuboCop; end + +class RuboCop::AST::ProcessedSource + include ::RuboCop::Ext::ProcessedSource +end + +class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node + include ::RuboCop::Ext::RegexpNode +end + +# The CLI is a class responsible of handling all the command line interface +# logic. +# +# source://rubocop-1.35.1/lib/rubocop/cli.rb:6 +class RuboCop::CLI + # @return [CLI] a new instance of CLI + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:22 + def initialize; end + + # Returns the value of attribute config_store. + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:20 + def config_store; end + + # Returns the value of attribute options. + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:20 + def options; end + + # Entry point for the application logic. Here we + # do the command line arguments processing and inspect + # the target files. + # + # + # @api public + # @param args [Array<String>] command line arguments + # @return [Integer] UNIX exit code + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:37 + def run(args = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:106 + def act_on_options; end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:140 + def apply_default_formatter; end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:75 + def execute_runners; end + + # @raise [Finished] + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:131 + def handle_exiting_options; end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:94 + def parallel_by_default!; end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:71 + def run_command(name); end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:123 + def set_options_to_config_loader; end + + # source://rubocop-1.35.1/lib/rubocop/cli.rb:83 + def suggest_extensions; end + + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/cli.rb:87 + def validate_options_vs_config; end +end + +# Home of subcommands in the CLI. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command.rb:7 +module RuboCop::CLI::Command + class << self + # Find the command with a given name and run it in an environment. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command.rb:10 + def run(env, name); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command.rb:16 + def class_for(name); end + end +end + +# Generate a configuration file acting as a TODO list. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:8 +class RuboCop::CLI::Command::AutoGenerateConfig < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:20 + def run; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:90 + def add_formatter; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:98 + def add_inheritance_from_auto_generated_file(config_file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:94 + def execute_runner; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:119 + def existing_configuration(config_file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:56 + def line_length_cop(config); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:44 + def line_length_enabled?(config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:52 + def max_line_length(config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:29 + def maybe_run_line_length_cop; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:141 + def options_config_in_root?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:132 + def relative_path_to_todo_from_options_config; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:83 + def reset_config_and_auto_gen_file; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:74 + def run_all_cops(line_length_contents); end + + # Do an initial run with only Layout/LineLength so that cops that + # depend on Layout/LineLength:Max get the correct value for that + # parameter. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:63 + def run_line_length_cop; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:48 + def same_max_line_length?(config1, config2); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:39 + def skip_line_length_cop(reason); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:125 + def write_config_file(file_name, file_string, rubocop_yml_contents); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:11 +RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:14 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1 = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:18 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_DISABLED = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:17 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_1_OVERRIDDEN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:15 +RuboCop::CLI::Command::AutoGenerateConfig::PHASE_2 = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/auto_generate_config.rb:12 +RuboCop::CLI::Command::AutoGenerateConfig::YAML_OPTIONAL_DOC_START = T.let(T.unsafe(nil), Regexp) + +# A subcommand in the CLI. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:8 +class RuboCop::CLI::Command::Base + # @api private + # @return [Base] a new instance of Base + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:26 + def initialize(env); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:9 + def env; end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:21 + def by_command_name(name); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:14 + def command_name; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:14 + def command_name=(_arg0); end + + # @api private + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/base.rb:16 + def inherited(subclass); end + end +end + +# Run all the selected cops and report the result. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:8 +class RuboCop::CLI::Command::ExecuteRunner < ::RuboCop::CLI::Command::Base + include ::RuboCop::Formatter::TextUtil + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:16 + def run; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:69 + def display_error_summary(errors); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:56 + def display_summary(runner); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:61 + def display_warning_summary(warnings); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:22 + def execute_runner(paths); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:86 + def maybe_print_corrected_source; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:42 + def with_redirect; end +end + +# Combination of short and long formatter names. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/execute_runner.rb:12 +RuboCop::CLI::Command::ExecuteRunner::INTEGRATION_FORMATTERS = T.let(T.unsafe(nil), Array) + +# Generate a .rubocop.yml file in the current directory. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/init_dotfile.rb:8 +class RuboCop::CLI::Command::InitDotfile < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/init_dotfile.rb:13 + def run; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/init_dotfile.rb:9 +RuboCop::CLI::Command::InitDotfile::DOTFILE = T.let(T.unsafe(nil), String) + +# Shows the given cops, or all cops by default, and their configurations +# for the current directory. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:9 +class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base + # @api private + # @return [ShowCops] a new instance of ShowCops + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:12 + def initialize(env); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:19 + def run; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:67 + def config_lines(cop); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:63 + def cops_of_department(cops, department); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:25 + def print_available_cops; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:48 + def print_cop_details(cops); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:36 + def print_cops_of_department(registry, department, show_all); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_cops.rb:57 + def selected_cops_of_department(cops, department); end +end + +# Prints out url to documentation of provided cops +# or documentation base url by default. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:9 +class RuboCop::CLI::Command::ShowDocsUrl < ::RuboCop::CLI::Command::Base + # @api private + # @return [ShowDocsUrl] a new instance of ShowDocsUrl + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:12 + def initialize(env); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:18 + def run; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:38 + def cops_array; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:24 + def print_documentation_url; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/show_docs_url.rb:42 + def registry_hash; end +end + +# Suggest RuboCop extensions to install based on Gemfile dependencies. +# Only primary dependencies are evaluated, so if a dependency depends on a +# gem with an extension, it is not suggested. However, if an extension is +# a transitive dependency, it will not be suggested. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:12 +class RuboCop::CLI::Command::SuggestExtensions < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:17 + def run; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:73 + def all_extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:69 + def current_formatter; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:104 + def dependent_gems; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:80 + def extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:96 + def installed_and_not_loaded_extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:84 + def installed_extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:108 + def installed_gems; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:92 + def loaded_extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:100 + def lockfile; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:88 + def not_installed_extensions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:41 + def print_install_suggestions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:51 + def print_load_suggestions; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:60 + def print_opt_out_instruction; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:112 + def puts(*args); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:30 + def skip?; end +end + +# Combination of short and long formatter names. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/suggest_extensions.rb:13 +RuboCop::CLI::Command::SuggestExtensions::INCLUDED_FORMATTERS = T.let(T.unsafe(nil), Array) + +# Display version. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/command/version.rb:8 +class RuboCop::CLI::Command::Version < ::RuboCop::CLI::Command::Base + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/command/version.rb:11 + def run; end +end + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:11 +RuboCop::CLI::DEFAULT_PARALLEL_OPTIONS = T.let(T.unsafe(nil), Array) + +# Execution environment for a CLI command. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:7 +class RuboCop::CLI::Environment + # @api private + # @return [Environment] a new instance of Environment + # + # source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:10 + def initialize(options, config_store, paths); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:8 + def config_store; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:8 + def options; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:8 + def paths; end + + # Run a command in this environment. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cli/environment.rb:17 + def run(name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:18 +class RuboCop::CLI::Finished < ::StandardError; end + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:9 +RuboCop::CLI::STATUS_ERROR = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:10 +RuboCop::CLI::STATUS_INTERRUPTED = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:8 +RuboCop::CLI::STATUS_OFFENSES = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cli.rb:7 +RuboCop::CLI::STATUS_SUCCESS = T.let(T.unsafe(nil), Integer) + +# This class represents the cache config of the caching RuboCop runs. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cache_config.rb:6 +class RuboCop::CacheConfig + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cache_config.rb:7 + def root_dir; end + end +end + +# Converts RuboCop objects to and from the serialization format JSON. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cached_data.rb:8 +class RuboCop::CachedData + # @api private + # @return [CachedData] a new instance of CachedData + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:9 + def initialize(filename); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:13 + def from_json(text); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:17 + def to_json(offenses); end + + private + + # Restore an offense object loaded from a JSON file. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:47 + def deserialize_offenses(offenses); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:40 + def message(offense); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cached_data.rb:23 + def serialize_offense(offense); end +end + +# and provides a way to check if each cop is enabled at arbitrary line. +# +# source://rubocop-1.35.1/lib/rubocop/comment_config.rb:6 +class RuboCop::CommentConfig + # @return [CommentConfig] a new instance of CommentConfig + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:11 + def initialize(processed_source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:31 + def comment_only_line?(line_number); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:23 + def cop_disabled_line_ranges; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:15 + def cop_enabled_at_line?(cop, line_number); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:27 + def extra_enabled_comments; end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:9 + def processed_source; end + + private + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:51 + def analyze; end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:67 + def analyze_cop(analysis, directive); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:87 + def analyze_disabled(analysis, directive); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:98 + def analyze_rest(analysis, directive); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:78 + def analyze_single_line(analysis, directive); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:107 + def cop_line_ranges(analysis); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:113 + def each_directive; end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:37 + def extra_enabled_comments_with_names(extras:, names:); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:131 + def handle_enable_all(directive, names, extras); end + + # Collect cops that have been disabled or enabled by name in a directive comment + # so that `Lint/RedundantCopEnableDirective` can register offenses correctly. + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:145 + def handle_switch(directive, names, extras); end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:124 + def non_comment_token_line_numbers; end + + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:120 + def qualified_cop_name(cop_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/comment_config.rb:7 +class RuboCop::CommentConfig::CopAnalysis < ::Struct + # Returns the value of attribute line_ranges + # + # @return [Object] the current value of line_ranges + def line_ranges; end + + # Sets the attribute line_ranges + # + # @param value [Object] the value to set the attribute line_ranges to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:7 + def line_ranges=(_); end + + # Returns the value of attribute start_line_number + # + # @return [Object] the current value of start_line_number + def start_line_number; end + + # Sets the attribute start_line_number + # + # @param value [Object] the value to set the attribute start_line_number to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/comment_config.rb:7 + def start_line_number=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# This class represents the configuration of the RuboCop application +# and all its cops. A Config is associated with a YAML configuration +# file from which it was read. Several different Configs can be used +# during a run of the rubocop program, if files in several +# directories are inspected. +# +# source://rubocop-1.35.1/lib/rubocop/config.rb:14 +class RuboCop::Config + include ::RuboCop::PathUtil + include ::RuboCop::FileFinder + extend ::Forwardable + + # @return [Config] a new instance of Config + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:24 + def initialize(hash = T.unsafe(nil), loaded_path = T.unsafe(nil)); end + + # source://RUBY_ROOT/forwardable.rb:226 + def [](*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def []=(*args, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:149 + def active_support_extensions_enabled?; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:92 + def add_excludes_from_higher_level(highest_config); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:172 + def allowed_camel_case_file?(file); end + + # Paths specified in configuration files starting with .rubocop are + # relative to the directory where that file is. Paths in other config files + # are relative to the current directory. This is so that paths in + # config/default.yml, for example, are not relative to RuboCop's config + # directory since that wouldn't work. + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:216 + def base_dir_for_path_parameters; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:241 + def bundler_lock_file_path; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:47 + def check; end + + # source://RUBY_ROOT/forwardable.rb:226 + def delete(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:104 + def deprecation_check; end + + # source://RUBY_ROOT/forwardable.rb:226 + def dig(*args, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:141 + def disabled_new_cops?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def each(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def each_key(*args, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:145 + def enabled_new_cops?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def fetch(*args, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:194 + def file_to_exclude?(file); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:153 + def file_to_include?(file); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:137 + def for_all_cops; end + + # Note: the 'Enabled' attribute is same as that returned by `for_cop` + # + # @return [Config] for the given cop merged with that of its department (if any) + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:124 + def for_badge(badge); end + + # Note: the 'Enabled' attribute is calculated according to the department's + # and 'AllCops' configuration; other attributes are not inherited. + # + # @return [Config] for the given cop / cop name. + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:118 + def for_cop(cop); end + + # Note: the 'Enabled' attribute will be present only if specified + # at the department's level + # + # @return [Config] for the given department name. + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:132 + def for_department(department_name); end + + # True if this is a config file that is shipped with RuboCop + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:72 + def internal?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def key?(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def keys(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:43 + def loaded_features; end + + # Returns the value of attribute loaded_path. + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:22 + def loaded_path; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:77 + def make_excludes_absolute; end + + # source://RUBY_ROOT/forwardable.rb:226 + def map(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def merge(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:207 + def path_relative_to_config(path); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:203 + def patterns_to_exclude; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:199 + def patterns_to_include; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:252 + def pending_cops; end + + # Returns true if there's a chance that an Include pattern matches hidden + # files, false if that's definitely not possible. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:186 + def possibly_include_hidden?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def replace(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:67 + def signature; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:237 + def smart_loaded_path; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:226 + def target_rails_version; end + + # source://RUBY_ROOT/forwardable.rb:226 + def target_ruby_version(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_h(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_hash(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:63 + def to_s; end + + # source://RUBY_ROOT/forwardable.rb:226 + def transform_values(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def validate(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:54 + def validate_after_resolution; end + + private + + # source://rubocop-1.35.1/lib/rubocop/config.rb:294 + def department_of(qualified_cop_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:282 + def enable_cop?(qualified_cop_name, cop_options); end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:270 + def read_rails_version_from_bundler_lock_file; end + + # source://rubocop-1.35.1/lib/rubocop/config.rb:266 + def target_rails_version_from_bundler_lock_file; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/config.rb:36 + def create(hash, path, check: T.unsafe(nil)); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/config.rb:19 +class RuboCop::Config::CopConfig < ::Struct + # Returns the value of attribute metadata + # + # @return [Object] the current value of metadata + def metadata; end + + # Sets the attribute metadata + # + # @param value [Object] the value to set the attribute metadata to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:19 + def metadata=(_); end + + # Returns the value of attribute name + # + # @return [Object] the current value of name + def name; end + + # Sets the attribute name + # + # @param value [Object] the value to set the attribute name to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/config.rb:19 + def name=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/config.rb:21 +RuboCop::Config::DEFAULT_RAILS_VERSION = T.let(T.unsafe(nil), Float) + +# This class has methods related to finding configuration path. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_finder.rb:8 +class RuboCop::ConfigFinder + extend ::RuboCop::FileFinder + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:19 + def find_config_path(target_dir); end + + # Returns the path RuboCop inferred as the root of the project. No file + # searches will go past this directory. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:26 + def project_root; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:17 + def project_root=(_arg0); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:59 + def expand_path(path); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:40 + def find_project_dotfile(target_dir); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:32 + def find_project_root; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:44 + def find_user_dotfile; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_finder.rb:52 + def find_user_xdg_config; end + end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_finder.rb:12 +RuboCop::ConfigFinder::DEFAULT_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_finder.rb:9 +RuboCop::ConfigFinder::DOTFILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_finder.rb:11 +RuboCop::ConfigFinder::RUBOCOP_HOME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_finder.rb:10 +RuboCop::ConfigFinder::XDG_CONFIG = T.let(T.unsafe(nil), String) + +# This class represents the configuration of the RuboCop application +# and all its cops. A Config is associated with a YAML configuration +# file from which it was read. Several different Configs can be used +# during a run of the rubocop program, if files in several +# directories are inspected. +# +# source://rubocop-1.35.1/lib/rubocop/config_loader.rb:18 +class RuboCop::ConfigLoader + extend ::RuboCop::FileFinder + + class << self + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:123 + def add_excludes_from_files(config, config_file); end + + # Used to add features that were required inside a config or from + # the CLI using `--require`. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:185 + def add_loaded_features(loaded_features); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:73 + def add_missing_namespaces(path, hash); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:34 + def clear_options; end + + # Returns the path of .rubocop.yml searching upwards in the + # directory structure starting at the given directory where the + # inspected file is. If no .rubocop.yml is found there, the + # user's home directory is checked. If there's no .rubocop.yml + # there either, the path to the default file is returned. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:97 + def configuration_file_for(target_dir); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:101 + def configuration_from_file(config_file, check: T.unsafe(nil)); end + + # Returns the value of attribute debug. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def debug; end + + # Sets the attribute debug + # + # @param value the value to set the attribute debug to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def debug=(_arg0); end + + # Returns the value of attribute debug. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def debug?; end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:133 + def default_configuration; end + + # Sets the attribute default_configuration + # + # @param value the value to set the attribute default_configuration to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:28 + def default_configuration=(_arg0); end + + # Returns the value of attribute disable_pending_cops. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def disable_pending_cops; end + + # Sets the attribute disable_pending_cops + # + # @param value the value to set the attribute disable_pending_cops to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def disable_pending_cops=(_arg0); end + + # Returns the value of attribute enable_pending_cops. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def enable_pending_cops; end + + # Sets the attribute enable_pending_cops + # + # @param value the value to set the attribute enable_pending_cops to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def enable_pending_cops=(_arg0); end + + # Returns the value of attribute ignore_parent_exclusion. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def ignore_parent_exclusion; end + + # Sets the attribute ignore_parent_exclusion + # + # @param value the value to set the attribute ignore_parent_exclusion to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def ignore_parent_exclusion=(_arg0); end + + # Returns the value of attribute ignore_parent_exclusion. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def ignore_parent_exclusion?; end + + # Returns the value of attribute ignore_unrecognized_cops. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def ignore_unrecognized_cops; end + + # Sets the attribute ignore_unrecognized_cops + # + # @param value the value to set the attribute ignore_unrecognized_cops to. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:26 + def ignore_unrecognized_cops=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:40 + def load_file(file, check: T.unsafe(nil)); end + + # @raise [TypeError] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:60 + def load_yaml_configuration(absolute_path); end + + # Returns the value of attribute loaded_features. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:29 + def loaded_features; end + + # Return a recursive merge of two hashes. That is, a normal hash merge, + # with the addition that any value that is a hash, and occurs in both + # arguments, will also be merged. And so on. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:88 + def merge(base_hash, derived_hash); end + + # Merges the given configuration with the default one. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:178 + def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:118 + def possible_new_cops?(config); end + + # Returns the path RuboCop inferred as the root of the project. No file + # searches will go past this directory. + # + # @deprecated Use `RuboCop::ConfigFinder.project_root` instead. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:143 + def project_root; end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:160 + def warn_on_pending_cops(pending_cops); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:170 + def warn_pending_cop(cop); end + + private + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:199 + def check_duplication(yaml_code, absolute_path); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:191 + def file_path(file); end + + # Read the specified file, or exit with a friendly, concise message on + # stderr. Care is taken to use the standard OS exit code for a "file not + # found" error. + # + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:219 + def read_file(absolute_path); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:195 + def resolver; end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:225 + def yaml_safe_load(yaml_code, filename); end + + # source://rubocop-1.35.1/lib/rubocop/config_loader.rb:236 + def yaml_safe_load!(yaml_code, filename); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/config_loader.rb:21 +RuboCop::ConfigLoader::DEFAULT_FILE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/config_loader.rb:19 +RuboCop::ConfigLoader::DOTFILE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/config_loader.rb:20 +RuboCop::ConfigLoader::RUBOCOP_HOME = T.let(T.unsafe(nil), String) + +# A help class for ConfigLoader that handles configuration resolution. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:9 +class RuboCop::ConfigLoaderResolver + # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the + # base configuration are relative to the directory where the base configuration file is. For the + # derived configuration, we need to make those paths relative to where the derived configuration + # file is. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:45 + def fix_include_paths(base_config_path, hash, path, key, value); end + + # Return a recursive merge of two hashes. That is, a normal hash merge, + # with the addition that any value that is a hash, and occurs in both + # arguments, will also be merged. And so on. + # + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:99 + def merge(base_hash, derived_hash, **opts); end + + # Merges the given configuration with the default one. If + # AllCops:DisabledByDefault is true, it changes the Enabled params so that + # only cops from user configuration are enabled. If + # AllCops:EnabledByDefault is true, it changes the Enabled params so that + # only cops explicitly disabled in user configuration are disabled. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:75 + def merge_with_default(config, config_file, unset_nil:); end + + # An `Enabled: true` setting in user configuration for a cop overrides an + # `Enabled: false` setting for its department. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:119 + def override_department_setting_for_cops(base_hash, derived_hash); end + + # If a cop was previously explicitly enabled, but then superseded by the + # department being disabled, disable it. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:136 + def override_enabled_for_disabled_departments(base_hash, derived_hash); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:19 + def resolve_inheritance(path, hash, file, debug); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:55 + def resolve_inheritance_from_gems(hash); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:10 + def resolve_requires(path, hash); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:208 + def base_configs(path, inherit_from, file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:176 + def determine_inherit_mode(hash, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:152 + def disabled?(hash, department); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:156 + def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:264 + def gem_config_path(gem_name, relative_config_path); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:242 + def handle_disabled_by_default(config, new_default_configuration); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:216 + def inherited_file(path, inherit_from, file); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:204 + def merge_hashes?(base_hash, derived_hash, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:237 + def remote_file?(uri); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:196 + def should_merge?(mode, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:200 + def should_override?(mode, key); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:182 + def should_union?(derived_hash, base_hash, root_mode, key); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:260 + def transform(config, &block); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_loader_resolver.rb:165 + def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end +end + +# Raised when a RuboCop configuration file is not found. +# +# source://rubocop-1.35.1/lib/rubocop/config_loader.rb:10 +class RuboCop::ConfigNotFoundError < ::RuboCop::Error; end + +# This class handles obsolete configuration. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:4 +class RuboCop::ConfigObsoletion + # @api private + # @return [ConfigObsoletion] a new instance of ConfigObsoletion + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:33 + def initialize(config); end + + # @api private + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:39 + def reject_obsolete!; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:19 + def rules; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:19 + def warnings; end + + private + + # Cop rules are keyed by the name of the original cop + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:69 + def load_cop_rules(rules); end + + # Parameter rules may apply to multiple cops and multiple parameters + # and are given as an array. Each combination is turned into a separate + # rule object. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:82 + def load_parameter_rules(rules); end + + # Default rules for obsoletions are in config/obsoletion.yml + # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename` + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:50 + def load_rules; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:95 + def obsoletions; end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:22 + def files; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:22 + def files=(_arg0); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:24 + def legacy_cop_names; end + end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:8 +RuboCop::ConfigObsoletion::COP_RULE_CLASSES = T.let(T.unsafe(nil), Hash) + +# Encapsulation of a ConfigObsoletion rule for changing a parameter +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_enforced_styles.rb:7 +class RuboCop::ConfigObsoletion::ChangedEnforcedStyles < ::RuboCop::ConfigObsoletion::ParameterRule + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_enforced_styles.rb:14 + def message; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_enforced_styles.rb:10 + def violated?; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_enforced_styles.rb:28 + def value; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_enforced_styles.rb:8 +RuboCop::ConfigObsoletion::ChangedEnforcedStyles::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for changing a parameter +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_parameter.rb:7 +class RuboCop::ConfigObsoletion::ChangedParameter < ::RuboCop::ConfigObsoletion::ParameterRule + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_parameter.rb:10 + def message; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/changed_parameter.rb:8 +RuboCop::ConfigObsoletion::ChangedParameter::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Base class for ConfigObsoletion rules relating to cops +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:7 +class RuboCop::ConfigObsoletion::CopRule < ::RuboCop::ConfigObsoletion::Rule + # @api private + # @return [CopRule] a new instance of CopRule + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:10 + def initialize(config, old_name); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:15 + def cop_rule?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:19 + def message; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:8 + def old_name; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:28 + def violated?; end + + # Cop rules currently can only be failures, not warnings + # + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/cop_rule.rb:24 + def warning?; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:7 +RuboCop::ConfigObsoletion::DEFAULT_RULES_FILE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for splitting a cop's +# functionality into multiple new cops. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:8 +class RuboCop::ConfigObsoletion::ExtractedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [ExtractedCop] a new instance of ExtractedCop + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:11 + def initialize(config, old_name, gem); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:9 + def department; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:9 + def gem; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:23 + def rule_message; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:17 + def violated?; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:32 + def affected_cops; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/extracted_cop.rb:41 + def feature_loaded?; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion.rb:14 +RuboCop::ConfigObsoletion::PARAMETER_RULE_CLASSES = T.let(T.unsafe(nil), Hash) + +# Base class for ConfigObsoletion rules relating to parameters +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:7 +class RuboCop::ConfigObsoletion::ParameterRule < ::RuboCop::ConfigObsoletion::Rule + # @api private + # @return [ParameterRule] a new instance of ParameterRule + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:10 + def initialize(config, cop, parameter, metadata); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:8 + def cop; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:8 + def metadata; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:8 + def parameter; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:17 + def parameter_rule?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:21 + def violated?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:25 + def warning?; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:31 + def alternative; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:35 + def alternatives; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:39 + def reason; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/parameter_rule.rb:43 + def severity; end +end + +# Encapsulation of a ConfigObsoletion rule for removing +# a previously defined cop. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:8 +class RuboCop::ConfigObsoletion::RemovedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [RemovedCop] a new instance of RemovedCop + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:13 + def initialize(config, old_name, metadata); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:9 + def metadata; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:9 + def old_name; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:18 + def rule_message; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:36 + def alternatives; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:32 + def reason; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/removed_cop.rb:11 +RuboCop::ConfigObsoletion::RemovedCop::BASE_MESSAGE = T.let(T.unsafe(nil), String) + +# Encapsulation of a ConfigObsoletion rule for renaming +# a cop or moving it to a new department. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:8 +class RuboCop::ConfigObsoletion::RenamedCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [RenamedCop] a new instance of RenamedCop + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:11 + def initialize(config, old_name, new_name); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:9 + def new_name; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:16 + def rule_message; end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:22 + def moved?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/renamed_cop.rb:29 + def verb; end +end + +# Abstract base class for ConfigObsoletion rules +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:7 +class RuboCop::ConfigObsoletion::Rule + # @api private + # @return [Rule] a new instance of Rule + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:8 + def initialize(config); end + + # Does this rule relate to cops? + # + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:13 + def cop_rule?; end + + # Does this rule relate to parameters? + # + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:18 + def parameter_rule?; end + + # @api private + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:22 + def violated?; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:28 + def config; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:36 + def smart_loaded_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/rule.rb:30 + def to_sentence(collection, connector: T.unsafe(nil)); end +end + +# Encapsulation of a ConfigObsoletion rule for splitting a cop's +# functionality into multiple new cops. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_obsoletion/split_cop.rb:8 +class RuboCop::ConfigObsoletion::SplitCop < ::RuboCop::ConfigObsoletion::CopRule + # @api private + # @return [SplitCop] a new instance of SplitCop + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/split_cop.rb:11 + def initialize(config, old_name, metadata); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/split_cop.rb:9 + def metadata; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/split_cop.rb:16 + def rule_message; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_obsoletion/split_cop.rb:22 + def alternatives; end +end + +# This class handles collecting the options for regenerating a TODO file. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:6 +class RuboCop::ConfigRegeneration + # Get options from the comment in the TODO file, and parse them as options + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:12 + def options; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:29 + def generation_command; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:25 + def todo_exists?; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:7 +RuboCop::ConfigRegeneration::AUTO_GENERATED_FILE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:8 +RuboCop::ConfigRegeneration::COMMAND_REGEX = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_regeneration.rb:9 +RuboCop::ConfigRegeneration::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash) + +# Handles caching of configurations and association of inspected +# ruby files to configurations. +# +# source://rubocop-1.35.1/lib/rubocop/config_store.rb:6 +class RuboCop::ConfigStore + # @return [ConfigStore] a new instance of ConfigStore + # + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:10 + def initialize; end + + # If type (file/dir) is known beforehand, + # prefer using #for_file or #for_dir for improved performance + # + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:52 + def for(file_or_dir); end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:61 + def for_dir(dir); end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:42 + def for_file(file); end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:46 + def for_pwd; end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:33 + def force_default_config!; end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:28 + def options_config=(options_config); end + + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:37 + def unvalidated; end + + # Returns the value of attribute validated. + # + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:7 + def validated; end + + # Returns the value of attribute validated. + # + # source://rubocop-1.35.1/lib/rubocop/config_store.rb:7 + def validated?; end +end + +# Handles validation of configuration, for example cop names, parameter +# names, and Ruby versions. +# +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:8 +class RuboCop::ConfigValidator + extend ::Forwardable + + # @return [ConfigValidator] a new instance of ConfigValidator + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:27 + def initialize(config); end + + # source://RUBY_ROOT/forwardable.rb:226 + def for_all_cops(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def smart_loaded_path(*args, &block); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:63 + def target_ruby_version; end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:33 + def validate; end + + # Validations that should only be run after all config resolving has + # taken place: + # * The target ruby version is only checked once the entire inheritance + # chain has been loaded so that only the final value is validated, and + # any obsolete but overridden values are ignored. + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:59 + def validate_after_resolution; end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:67 + def validate_section_presence(name); end + + private + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:104 + def alert_about_unrecognized_cops(invalid_cop_names); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:253 + def check_cop_config_value(hash, parent = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:77 + def check_obsoletions; end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:84 + def check_target_ruby; end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:195 + def each_invalid_parameter(cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:120 + def list_unknown_cops(invalid_cop_names); end + + # FIXME: Handling colors in exception messages like this is ugly. + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:266 + def msg_not_boolean(parent, key, value); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:242 + def reject_conflicting_safe_settings; end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:233 + def reject_mutually_exclusive_defaults; end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:142 + def suggestion(name); end + + # Returns the value of attribute target_ruby. + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:75 + def target_ruby; end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:207 + def validate_enforced_styles(valid_cop_names); end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:169 + def validate_new_cops_parameter; end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:180 + def validate_parameter_names(valid_cop_names); end + + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:227 + def validate_support_and_has_list(name, formats, valid); end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/config_validator.rb:158 + def validate_syntax_cop; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:12 +RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:22 +RuboCop::ConfigValidator::CONFIG_CHECK_DEPARTMENTS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:21 +RuboCop::ConfigValidator::CONFIG_CHECK_KEYS = T.let(T.unsafe(nil), Set) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:14 +RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/config_validator.rb:18 +RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/util.rb:4 +module RuboCop::Cop; end + +# This module checks for nodes that should be aligned to the left or right. +# This amount is determined by the instance variable @column_delta. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:7 +module RuboCop::Cop::Alignment + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:26 + def check_alignment(items, base_column = T.unsafe(nil)); end + + # Returns the value of attribute column_delta. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:12 + def column_delta; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:14 + def configured_indentation_width; end + + # @api public + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:58 + def display_column(range); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:45 + def each_bad_alignment(items, base_column); end + + # @deprecated Use processed_source.comment_at_line(line) + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:69 + def end_of_line_comment(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:18 + def indentation(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:22 + def offset(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:74 + def register_offense(offense_node, message_node); end + + # @api public + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:64 + def within?(inner, outer); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/alignment.rb:10 +RuboCop::Cop::Alignment::SPACE = T.let(T.unsafe(nil), String) + +# This class does autocorrection of nodes that should just be moved to +# the left or to the right, amount being determined by the instance +# variable column_delta. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:8 +class RuboCop::Cop::AlignmentCorrector + extend ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::Alignment + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:29 + def align_end(corrector, processed_source, node, align_to); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:15 + def correct(corrector, processed_source, node, column_delta); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:13 + def processed_source; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:124 + def alignment_column(align_to); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:40 + def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:81 + def block_comment_within?(expr); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:87 + def calculate_range(expr, line_begin_pos, column_delta); end + + # Some special kinds of string literals are not composed of literal + # characters between two delimiters: + # - The source map of `?a` responds to :begin and :end but its end is + # nil. + # - The source map of `__FILE__` responds to neither :begin nor :end. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:75 + def delimited_string_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:110 + def each_line(expr); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:60 + def inside_string_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:54 + def inside_string_ranges(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:99 + def remove(range, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/alignment_corrector.rb:118 + def whitespace_range(node); end + end +end + +# This module encapsulates the ability to allow certain identifiers in a cop. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_identifiers.rb:6 +module RuboCop::Cop::AllowedIdentifiers + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_identifiers.rb:9 + def allowed_identifier?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_identifiers.rb:13 + def allowed_identifiers; end +end + +# if a variable starts with a sigil it will be removed +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_identifiers.rb:7 +RuboCop::Cop::AllowedIdentifiers::SIGILS = T.let(T.unsafe(nil), String) + +# This module encapsulates the ability to allow certain methods when +# parsing. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:7 +module RuboCop::Cop::AllowedMethods + private + + # @api public + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:11 + def allowed_method?(name); end + + # @api public + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:19 + def allowed_methods; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:28 + def cop_config_deprecated_values; end + + # @api public + # @deprecated Use allowed_method? instead + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:11 + def ignored_method?(name); end +end + +# This module encapsulates the ability to ignore certain lines when +# parsing. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:7 +module RuboCop::Cop::AllowedPattern + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:10 + def allowed_line?(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:30 + def allowed_patterns; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:40 + def cop_config_deprecated_methods_values; end + + # @deprecated Use allowed_line? instead + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:10 + def ignored_line?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:23 + def matches_allowed_pattern?(line); end + + # @deprecated Use matches_allowed_pattern?? instead + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:23 + def matches_ignored_pattern?(line); end +end + +# Error raised when an unqualified cop name is used that could +# refer to two or more cops under different departments +# +# source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:7 +class RuboCop::Cop::AmbiguousCopName < ::RuboCop::Error + # @return [AmbiguousCopName] a new instance of AmbiguousCopName + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:11 + def initialize(name, origin, badges); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:8 +RuboCop::Cop::AmbiguousCopName::MSG = T.let(T.unsafe(nil), String) + +# Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`). +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:6 +class RuboCop::Cop::AnnotationComment + extend ::Forwardable + + # @param comment [Parser::Source::Comment] + # @param keywords [Array<String>] + # @return [AnnotationComment] a new instance of AnnotationComment + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:13 + def initialize(comment, keywords); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:19 + def annotation?; end + + # Returns the range bounds for just the annotation + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:31 + def bounds; end + + # Returns the value of attribute colon. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def colon; end + + # Returns the value of attribute comment. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def comment; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:23 + def correct?(colon:); end + + # Returns the value of attribute keyword. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def keyword; end + + # Returns the value of attribute margin. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def margin; end + + # Returns the value of attribute note. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def note; end + + # Returns the value of attribute space. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:9 + def space; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:60 + def just_keyword_of_sentence?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:56 + def keyword_appearance?; end + + # Returns the value of attribute keywords. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:39 + def keywords; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/annotation_comment.rb:41 + def split_comment(comment); end +end + +# Handles the `MinSize` configuration option for array-based cops +# `Style/SymbolArray` and `Style/WordArray`, which check for use of the +# relevant percent literal syntax such as `%i[...]` and `%w[...]` +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:8 +module RuboCop::Cop::ArrayMinSize + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:19 + def array_style_detected(style, ary_size); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:11 + def below_array_length?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:38 + def largest_brackets_size(style, ary_size); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:15 + def min_size_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_min_size.rb:48 + def smallest_percent_size(style, ary_size); end +end + +# Common code for ordinary arrays with [] that can be written with % +# syntax. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_syntax.rb:7 +module RuboCop::Cop::ArraySyntax + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/array_syntax.rb:10 + def bracketed_array_of?(element_type, node); end +end + +# extend this module to signal autocorrection support +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/auto_corrector.rb:6 +module RuboCop::Cop::AutoCorrector + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/auto_corrector.rb:7 + def support_autocorrect?; end +end + +# This module encapsulates the logic for autocorrect behavior for a cop. +# +# source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:6 +module RuboCop::Cop::AutocorrectLogic + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:7 + def autocorrect?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:31 + def autocorrect_enabled?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:15 + def autocorrect_requested?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:11 + def autocorrect_with_disable_uncorrectable?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:19 + def correctable?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:23 + def disable_uncorrectable?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:27 + def safe_autocorrect?; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:46 + def disable_offense(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:95 + def disable_offense_at_end_of_line(range, eol_comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:99 + def disable_offense_before_and_after(range_by_lines); end + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:91 + def max_line_length; end + + # Expand the given range to include all of any lines it covers. Does not + # include newline at end of the last line. + # + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:81 + def range_by_lines(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:72 + def range_of_first_line(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/autocorrect_logic.rb:61 + def surrounding_heredoc(offense_range); end +end + +# Identifier of all cops containing a department and cop name. +# +# All cops are identified by their badge. For example, the badge for +# `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`. +# Badges can be parsed as either `Department/CopName` or just `CopName` to +# allow for badge references in source files that omit the department for +# RuboCop to infer. +# +# source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:12 +class RuboCop::Cop::Badge + # @return [Badge] a new instance of Badge + # + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:31 + def initialize(class_name_parts); end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:37 + def ==(other); end + + # Returns the value of attribute cop_name. + # + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:13 + def cop_name; end + + # Returns the value of attribute department. + # + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:13 + def department; end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:37 + def eql?(other); end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:42 + def hash; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:46 + def match?(other); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:54 + def qualified?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:50 + def to_s; end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:58 + def with_department(department); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:25 + def camel_case(name_part); end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:15 + def for(class_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/badge.rb:21 + def parse(identifier); end + end +end + +# A scaffold for concrete cops. +# +# The Cop::Base class is meant to be extended. +# +# Cops track offenses and can autocorrect them on the fly. +# +# A commissioner object is responsible for traversing the AST and invoking +# the specific callbacks on each cop. +# +# First the callback `on_new_investigation` is called; +# if a cop needs to do its own processing of the AST or depends on +# something else. +# +# Then callbacks like `on_def`, `on_send` (see AST::Traversal) are called +# with their respective nodes. +# +# Finally the callback `on_investigation_end` is called. +# +# Within these callbacks, cops are meant to call `add_offense` or +# `add_global_offense`. Use the `processed_source` method to +# get the currently processed source being investigated. +# +# In case of invalid syntax / unparsable content, +# the callback `on_other_file` is called instead of all the other +# `on_...` callbacks. +# +# Private methods are not meant for custom cops consumption, +# nor are any instance variables. +# +# source://rubocop-1.35.1/lib/rubocop/cop/base.rb:34 +class RuboCop::Cop::Base + include ::RuboCop::AST::Sexp + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + include ::RuboCop::Cop::IgnoredNode + include ::RuboCop::Cop::AutocorrectLogic + extend ::RuboCop::AST::Sexp + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::ExcludeLimit + + # @return [Base] a new instance of Base + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:71 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:223 + def active_support_extensions_enabled?; end + + # Adds an offense that has no particular location. + # No correction can be applied to global offenses + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:107 + def add_global_offense(message = T.unsafe(nil), severity: T.unsafe(nil)); end + + # Adds an offense on the specified range (or node with an expression) + # Unless that offense is disabled for this range, a corrector will be yielded + # to provide the cop the opportunity to autocorrect the offense. + # If message is not specified, the method `message` will be called. + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:118 + def add_offense(node_or_range, message: T.unsafe(nil), severity: T.unsafe(nil), &block); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:274 + def callbacks_needed; end + + # Returns the value of attribute config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:43 + def config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:207 + def config_to_allow_offenses; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:211 + def config_to_allow_offenses=(hash); end + + # Configuration Helpers + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:201 + def cop_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:193 + def cop_name; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:233 + def excluded_file?(file); end + + # This method should be overridden when a cop's behavior depends + # on state that lives outside of these locations: + # + # (1) the file under inspection + # (2) the cop's source code + # (3) the config (eg a .rubocop.yml file) + # + # For example, some cops may want to look at other parts of + # the codebase being inspected to find violations. A cop may + # use the presence or absence of file `foo.rb` to determine + # whether a certain violation exists in `bar.rb`. + # + # Overriding this method allows the cop to indicate to RuboCop's + # ResultCache system when those external dependencies change, + # ie when the ResultCache should be invalidated. + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:147 + def external_dependency_checksum; end + + # Gets called if no message is specified when calling `add_offense` or + # `add_global_offense` + # Cops are discouraged to override this; instead pass your message directly + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:101 + def message(_range = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:193 + def name; end + + # @deprecated Make potential errors with previous API more obvious + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:266 + def offenses; end + + # Called after all on_... have been called + # When refining this method, always call `super` + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:85 + def on_investigation_end; end + + # Called before all on_... have been called + # When refining this method, always call `super` + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:79 + def on_new_investigation; end + + # Called instead of all on_... callbacks for unrecognized files / syntax errors + # When refining this method, always call `super` + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:91 + def on_other_file; end + + # There should be very limited reasons for a Cop to do it's own parsing + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:238 + def parse(source, path = T.unsafe(nil)); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:43 + def processed_source; end + + # Called between investigations + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:257 + def ready; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:227 + def relevant_file?(file); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:219 + def target_rails_version; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:215 + def target_ruby_version; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:405 + def annotate(message); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:294 + def apply_correction(corrector); end + + # @return [Symbol] offense status + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:369 + def attempt_correction(range, corrector); end + + # Called before any investigation + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:313 + def begin_investigation(processed_source); end + + # Reserved for Cop::Cop + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:290 + def callback_argument(range); end + + # Called to complete an investigation + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:322 + def complete_investigation; end + + # @return [Symbol, Corrector] offense status + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:343 + def correct(range); end + + # Reserved for Commissioner: + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:300 + def current_offense_locations; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:304 + def currently_disabled_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:440 + def custom_severity; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:436 + def default_severity; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:383 + def disable_uncorrectable(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:426 + def enabled_line?(line_number); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:411 + def file_name_matches_any?(file, parameter, default_result); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:401 + def find_message(range, message); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:432 + def find_severity(_range, severity); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:390 + def range_from_node_or_range(node_or_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:338 + def reset_investigation; end + + # @return [Symbol] offense status + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:358 + def use_corrector(range, corrector); end + + class << self + # List of cops that should not try to autocorrect at the same + # time as this cop + # + # @api public + # @return [Array<RuboCop::Cop::Cop>] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:59 + def autocorrect_incompatible_with; end + + # Naming + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:169 + def badge; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:279 + def callbacks_needed; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:173 + def cop_name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:177 + def department; end + + # Cops (other than builtin) are encouraged to implement this + # + # @api public + # @return [String, nil] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:67 + def documentation_url; end + + # Call for abstract Cop classes + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:157 + def exclude_from_registry; end + + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:151 + def inherited(subclass); end + + # Override and return the Force class(es) you need to join + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:96 + def joining_forces; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:181 + def lint?; end + + # Returns true if the cop name or the cop namespace matches any of the + # given names. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:187 + def match?(given_names); end + + # Returns if class supports autocorrect. + # It is recommended to extend AutoCorrector instead of overriding + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:163 + def support_autocorrect?; end + + # Override if your cop should be called repeatedly for multiple investigations + # Between calls to `on_new_investigation` and `on_investigation_end`, + # the result of `processed_source` will remain constant. + # You should invalidate any caches that depend on the current `processed_source` + # in the `on_new_investigation` callback. + # If your cop does autocorrections, be aware that your instance may be called + # multiple times with the same `processed_source.path` but different content. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:251 + def support_multiple_source?; end + + private + + # Actually private methods + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:330 + def builtin?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:308 + def restrict_on_send; end + end +end + +# Reports of an investigation. +# Immutable +# Consider creation API private +# +# source://rubocop-1.35.1/lib/rubocop/cop/base.rb:48 +class RuboCop::Cop::Base::InvestigationReport < ::Struct + # Returns the value of attribute cop + # + # @return [Object] the current value of cop + def cop; end + + # Sets the attribute cop + # + # @param value [Object] the value to set the attribute cop to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:48 + def cop=(_); end + + # Returns the value of attribute corrector + # + # @return [Object] the current value of corrector + def corrector; end + + # Sets the attribute corrector + # + # @param value [Object] the value to set the attribute corrector to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:48 + def corrector=(_); end + + # Returns the value of attribute offenses + # + # @return [Object] the current value of offenses + def offenses; end + + # Sets the attribute offenses + # + # @param value [Object] the value to set the attribute offenses to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:48 + def offenses=(_); end + + # Returns the value of attribute processed_source + # + # @return [Object] the current value of processed_source + def processed_source; end + + # Sets the attribute processed_source + # + # @param value [Object] the value to set the attribute processed_source to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/base.rb:48 + def processed_source=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# List of methods names to restrict calls for `on_send` / `on_csend` +# +# source://rubocop-1.35.1/lib/rubocop/cop/base.rb:51 +RuboCop::Cop::Base::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:5 +module RuboCop::Cop::Bundler; end + +# A Gem's requirements should be listed only once in a Gemfile. +# +# @example +# # bad +# gem 'rubocop' +# gem 'rubocop' +# +# # bad +# group :development do +# gem 'rubocop' +# end +# +# group :test do +# gem 'rubocop' +# end +# +# # good +# group :development, :test do +# gem 'rubocop' +# end +# +# # good +# gem 'rubocop', groups: [:development, :test] +# +# # good - conditional declaration +# if Dir.exist?(local) +# gem 'rubocop', path: local +# elsif ENV['RUBOCOP_VERSION'] == 'master' +# gem 'rubocop', git: 'https://github.com/rubocop/rubocop.git' +# else +# gem 'rubocop', '~> 0.90.0' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:38 +class RuboCop::Cop::Bundler::DuplicatedGem < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:57 + def gem_declarations(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:44 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:66 + def conditional_declaration?(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:59 + def duplicated_gem_nodes; end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:80 + def register_offense(node, gem_name, line_of_first_occurrence); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:74 + def within_conditional?(node, conditional_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/duplicated_gem.rb:41 +RuboCop::Cop::Bundler::DuplicatedGem::MSG = T.let(T.unsafe(nil), String) + +# Each gem in the Gemfile should have a comment explaining +# its purpose in the project, or the reason for its version +# or source. +# +# The optional "OnlyFor" configuration array +# can be used to only register offenses when the gems +# use certain options or have version specifiers. +# +# When "version_specifiers" is included, a comment +# will be enforced if the gem has any version specifier. +# +# When "restrictive_version_specifiers" is included, a comment +# will be enforced if the gem has a version specifier that +# holds back the version of the gem. +# +# For any other value in the array, a comment will be enforced for +# a gem if an option by the same name is present. +# A useful use case is to enforce a comment when using +# options that change the source of a gem: +# +# - `bitbucket` +# - `gist` +# - `git` +# - `github` +# - `source` +# +# For a full list of options supported by bundler, +# see https://bundler.io/man/gemfile.5.html +# . +# +# @example OnlyFor: [] (default) +# # bad +# +# gem 'foo' +# +# # good +# +# # Helpers for the foo things. +# gem 'foo' +# @example OnlyFor: ['version_specifiers'] +# # bad +# +# gem 'foo', '< 2.1' +# +# # good +# +# # Version 2.1 introduces breaking change baz +# gem 'foo', '< 2.1' +# @example OnlyFor: ['restrictive_version_specifiers'] +# # bad +# +# gem 'foo', '< 2.1' +# +# # good +# +# gem 'foo', '>= 1.0' +# +# # Version 2.1 introduces breaking change baz +# gem 'foo', '< 2.1' +# @example OnlyFor: ['version_specifiers', 'github'] +# # bad +# +# gem 'foo', github: 'some_account/some_fork_of_foo' +# +# gem 'bar', '< 2.1' +# +# # good +# +# # Using this fork because baz +# gem 'foo', github: 'some_account/some_fork_of_foo' +# +# # Version 2.1 introduces breaking change baz +# gem 'bar', '< 2.1' +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:83 +class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::DefNode + include ::RuboCop::Cop::GemDeclaration + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:94 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:135 + def checked_options_present?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:109 + def commented?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:105 + def commented_any_descendant?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:159 + def contains_checked_options?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:163 + def gem_options(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:130 + def ignored_gem?(node); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:116 + def precede?(node1, node2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:126 + def preceding_comment?(node1, node2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:120 + def preceding_lines(node); end + + # Version specifications that restrict all updates going forward. This excludes versions + # like ">= 1.0" or "!= 2.0.3". + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:152 + def restrictive_version_specified_gem?(node); end + + # Besides the gem name, all other *positional* arguments to `gem` are version specifiers, + # as long as it has one we know there's at least one version specifier. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:145 + def version_specified_gem?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:88 +RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:87 +RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:91 +RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:90 +RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:92 +RuboCop::Cop::Bundler::GemComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_comment.rb:89 +RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) + +# Verifies that a project contains Gemfile or gems.rb file and correct +# associated lock file based on the configuration. +# +# @example EnforcedStyle: Gemfile (default) +# # bad +# Project contains gems.rb and gems.locked files +# +# # bad +# Project contains Gemfile and gems.locked file +# +# # good +# Project contains Gemfile and Gemfile.lock +# @example EnforcedStyle: gems.rb +# # bad +# Project contains Gemfile and Gemfile.lock files +# +# # bad +# Project contains gems.rb and Gemfile.lock file +# +# # good +# Project contains gems.rb and gems.locked files +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:28 +class RuboCop::Cop::Bundler::GemFilename < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:43 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:88 + def expected_gemfile?(basename); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:80 + def gemfile_offense?(basename); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:93 + def gemfile_required?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:84 + def gems_rb_offense?(basename); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:97 + def gems_rb_required?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:58 + def register_gemfile_offense(file_path, basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:69 + def register_gems_rb_offense(file_path, basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:53 + def register_offense(file_path, basename); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:40 +RuboCop::Cop::Bundler::GemFilename::GEMFILE_FILES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:41 +RuboCop::Cop::Bundler::GemFilename::GEMS_RB_FILES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:36 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_MISMATCHED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:32 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMFILE_REQUIRED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:38 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_MISMATCHED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_filename.rb:34 +RuboCop::Cop::Bundler::GemFilename::MSG_GEMS_RB_REQUIRED = T.let(T.unsafe(nil), String) + +# Enforce that Gem version specifications or a commit reference (branch, +# ref, or tag) are either required or forbidden. +# +# @example EnforcedStyle: required (default) +# # bad +# gem 'rubocop' +# +# # good +# gem 'rubocop', '~> 1.12' +# +# # good +# gem 'rubocop', '>= 1.10.0' +# +# # good +# gem 'rubocop', '>= 1.5.0', '< 1.10.0' +# +# # good +# gem 'rubocop', branch: 'feature-branch' +# +# # good +# gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b' +# +# # good +# gem 'rubocop', tag: 'v1.17.0' +# @example EnforcedStyle: forbidden +# # good +# gem 'rubocop' +# +# # bad +# gem 'rubocop', '~> 1.12' +# +# # bad +# gem 'rubocop', '>= 1.10.0' +# +# # bad +# gem 'rubocop', '>= 1.5.0', '< 1.10.0' +# +# # bad +# gem 'rubocop', branch: 'feature-branch' +# +# # bad +# gem 'rubocop', ref: '74b5bfbb2c4b6fd6cdbbc7254bd7084b36e0c85b' +# +# # bad +# gem 'rubocop', tag: 'v1.17.0' +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:53 +class RuboCop::Cop::Bundler::GemVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::GemDeclaration + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:67 + def includes_commit_reference?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:62 + def includes_version_specification?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:85 + def allowed_gem?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:89 + def allowed_gems; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:113 + def forbidden_offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:119 + def forbidden_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:93 + def message(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:103 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:107 + def required_offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:123 + def required_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:127 + def version_specification?(expression); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:58 +RuboCop::Cop::Bundler::GemVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:57 +RuboCop::Cop::Bundler::GemVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/gem_version.rb:59 +RuboCop::Cop::Bundler::GemVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp) + +# Passing symbol arguments to `source` (e.g. `source :rubygems`) is +# deprecated because they default to using HTTP requests. Instead, specify +# `'https://rubygems.org'` if possible, or `'http://rubygems.org'` if not. +# +# When autocorrecting, this cop will replace symbol arguments with +# `'https://rubygems.org'`. +# +# This cop will not replace existing sources that use `http://`. This may +# be necessary where HTTPS is not available. For example, where using an +# internal gem server via an intranet, or where HTTPS is prohibited. +# However, you should strongly prefer `https://` where possible, as it is +# more secure. +# +# If you don't allow `http://`, please set `false` to `AllowHttpProtocol`. +# This option is `true` by default for safe autocorrection. +# +# @example +# # bad +# source :gemcutter +# source :rubygems +# source :rubyforge +# +# # good +# source 'https://rubygems.org' # strongly recommended +# @example AllowHttpProtocol: true (default) +# +# # good +# source 'http://rubygems.org' # use only if HTTPS is unavailable +# @example AllowHttpProtocol: false +# +# # bad +# source 'http://rubygems.org' +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:41 +class RuboCop::Cop::Bundler::InsecureProtocolSource < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:54 + def insecure_protocol_source?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:59 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:80 + def allow_http_protocol?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:45 +RuboCop::Cop::Bundler::InsecureProtocolSource::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:49 +RuboCop::Cop::Bundler::InsecureProtocolSource::MSG_HTTP_PROTOCOL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/insecure_protocol_source.rb:51 +RuboCop::Cop::Bundler::InsecureProtocolSource::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Gems should be alphabetically sorted within groups. +# +# @example +# # bad +# gem 'rubocop' +# gem 'rspec' +# +# # good +# gem 'rspec' +# gem 'rubocop' +# +# # good +# gem 'rubocop' +# +# gem 'rspec' +# +# # good only if TreatCommentsAsGroupSeparators is true +# # For code quality +# gem 'rubocop' +# # For tests +# gem 'rspec' +# +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/ordered_gems.rb:27 +class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/ordered_gems.rb:56 + def gem_declarations(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/ordered_gems.rb:35 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/bundler/ordered_gems.rb:49 + def previous_declaration(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/bundler/ordered_gems.rb:31 +RuboCop::Cop::Bundler::OrderedGems::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking assignment nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:6 +module RuboCop::Cop::CheckAssignment + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:7 + def on_or_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:19 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:29 + def extract_rhs(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_assignment.rb:29 + def extract_rhs(node); end + end +end + +# This mixin detects collections that are safe to "break" +# by inserting new lines. This is useful for breaking +# up long lines. +# +# Let's look at hashes as an example: +# +# We know hash keys are safe to break across lines. We can add +# linebreaks into hashes on lines longer than the specified maximum. +# Then in further passes cops can clean up the multi-line hash. +# For example, say the maximum line length is as indicated below: +# +# | +# v +# {foo: "0000000000", bar: "0000000000", baz: "0000000000"} +# +# In a LineLength autocorrection pass, a line is added before +# the first key that exceeds the column limit: +# +# {foo: "0000000000", bar: "0000000000", +# baz: "0000000000"} +# +# In a MultilineHashKeyLineBreaks pass, lines are inserted +# before all keys: +# +# {foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000"} +# +# Then in future passes FirstHashElementLineBreak, +# MultilineHashBraceLayout, and TrailingCommaInHashLiteral will +# manipulate as well until we get: +# +# { +# foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000", +# } +# +# (Note: Passes may not happen exactly in this sequence.) +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:44 +module RuboCop::Cop::CheckLineBreakable + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:45 + def extract_breakable_node(node, max); end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:200 + def all_on_same_line?(nodes); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:220 + def already_on_multiple_lines?(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:133 + def breakable_collection?(node, elements); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:187 + def children_could_be_broken_up?(children); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:150 + def contained_by_breakable_collection_on_same_line?(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:170 + def contained_by_multiline_collection_that_could_be_broken_up?(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:60 + def extract_breakable_node_from_elements(node, elements, max); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:72 + def extract_first_element_over_column_limit(node, elements, max); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:92 + def first_argument_is_heredoc?(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:207 + def process_args(args); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:117 + def safe_to_ignore?(node); end + + # If a send node contains a heredoc argument, splitting cannot happen + # after the heredoc or else it will cause a syntax error. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:101 + def shift_elements_for_heredoc_arg(node, elements, index); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/check_line_breakable.rb:112 + def within_column_limit?(element, max, line); end +end + +# Common functionality for checking length of code segments. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:6 +module RuboCop::Cop::CodeLength + extend ::RuboCop::ExcludeLimit + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:49 + def build_code_length_calculator(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:31 + def check_code_length(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:27 + def count_as_one; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:23 + def count_comments?; end + + # Returns true for lines that shall not be included in the count. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:45 + def irrelevant_line(source_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:19 + def max_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:15 + def message(length, max_length); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/code_length.rb:9 +RuboCop::Cop::CodeLength::MSG = T.let(T.unsafe(nil), String) + +# Help methods for working with nodes containing comments. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:6 +module RuboCop::Cop::CommentsHelp + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:18 + def comments_in_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:14 + def contains_comments?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:7 + def source_range_with_comment(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:32 + def begin_pos_with_comment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:46 + def buffer; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:27 + def end_position_for(node); end + + # Returns the end line of a node, which might be a comment and not part of the AST + # End line is considered either the line at which another node starts, or + # the line at which the parent node ends. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:54 + def find_end_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/comments_help.rb:42 + def start_line_position(node); end +end + +# Commissioner class is responsible for processing the AST and delegating +# work to the specified cops. +# +# source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:7 +class RuboCop::Cop::Commissioner + include ::RuboCop::AST::Traversal + + # @return [Commissioner] a new instance of Commissioner + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:44 + def initialize(cops, forces = T.unsafe(nil), options = T.unsafe(nil)); end + + # Returns the value of attribute errors. + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:42 + def errors; end + + # @return [InvestigationReport] + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:79 + def investigate(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on___ENCODING__(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on___FILE__(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on___LINE__(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_alias(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_arg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_arg_expr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_array_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_array_pattern_with_tail(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_back_ref(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_block_pass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_blockarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_break(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_cbase(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_complex(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_const(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_const_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_cvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_defined?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_dstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_dsym(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_eflipflop(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_empty_else(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_ensure(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_erange(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_false(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_find_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_float(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_forward_arg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_forward_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_forwarded_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_gvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_hash_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_if_guard(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_iflipflop(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_in_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_in_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_index(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_indexasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_int(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_irange(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_ivar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwargs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwbegin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwnilarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwoptarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwrestarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_kwsplat(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_lambda(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_lvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_alt(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_as(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_current_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_nil_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_pattern_p(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_rest(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_var(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_with_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_match_with_trailing_comma(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_mlhs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_next(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_nil(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_not(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_nth_ref(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_optarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_or_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_pair(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_pin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_postexe(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_preexe(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_procarg0(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_rational(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_redo(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_regexp(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_regopt(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_restarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_retry(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_return(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_sclass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_self(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_shadowarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_splat(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_str(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_super(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_sym(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_true(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_undef(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_unless_guard(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_when(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_while_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_xstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_yield(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:68 + def on_zsuper(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:114 + def build_callbacks(cops); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:109 + def initialize_callbacks; end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:152 + def invoke(callback, cops, *args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:105 + def reset; end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:124 + def restrict_callbacks(callbacks); end + + # NOTE: mutates `callbacks` in place + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:142 + def restricted_map(callbacks); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:97 + def trigger_responding_cops(callback, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:132 + def trigger_restricted_cops(event, node); end + + # Allow blind rescues here, since we're absorbing and packaging or + # re-raising exceptions that can be raised from within the individual + # cops' `#investigate` methods. + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:159 + def with_cop_error_handling(cop, node = T.unsafe(nil)); end +end + +# How a Commissioner returns the results of the investigation +# as a list of Cop::InvestigationReport and any errors caught +# during the investigation. +# Immutable +# Consider creation API private +# +# source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:18 +class RuboCop::Cop::Commissioner::InvestigationReport < ::Struct + # Returns the value of attribute cop_reports + # + # @return [Object] the current value of cop_reports + def cop_reports; end + + # Sets the attribute cop_reports + # + # @param value [Object] the value to set the attribute cop_reports to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:18 + def cop_reports=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:19 + def cops; end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:27 + def correctors; end + + # Returns the value of attribute errors + # + # @return [Object] the current value of errors + def errors; end + + # Sets the attribute errors + # + # @param value [Object] the value to set the attribute errors to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:18 + def errors=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:35 + def merge(investigation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:31 + def offenses; end + + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:23 + def offenses_per_cop; end + + # Returns the value of attribute processed_source + # + # @return [Object] the current value of processed_source + def processed_source; end + + # Sets the attribute processed_source + # + # @param value [Object] the value to set the attribute processed_source to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:18 + def processed_source=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/commissioner.rb:10 +RuboCop::Cop::Commissioner::RESTRICTED_CALLBACKS = T.let(T.unsafe(nil), Array) + +# This class does condition autocorrection +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/condition_corrector.rb:6 +class RuboCop::Cop::ConditionCorrector + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/condition_corrector.rb:8 + def correct_negative_condition(corrector, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/condition_corrector.rb:17 + def negated_condition(node); end + end +end + +# Handles `EnforcedStyle` configuration parameters. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:6 +module RuboCop::Cop::ConfigurableEnforcedStyle + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:76 + def alternative_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:84 + def alternative_styles; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:19 + def ambiguous_style_detected(*possibilities); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:48 + def conflicting_styles_detected; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:11 + def correct_style_detected; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:52 + def detected_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:56 + def detected_style=(style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:48 + def no_acceptable_style!; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:44 + def no_acceptable_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:7 + def opposite_style_detected; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:67 + def style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:63 + def style_configured?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:23 + def style_detected(detected); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:95 + def style_parameter_name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:88 + def supported_styles; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:15 + def unexpected_style_detected(unexpected); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_enforced_style.rb:48 + def unrecognized_style_detected; end +end + +# Shared functionality between mixins that enforce naming conventions +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_formatting.rb:6 +module RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_formatting.rb:9 + def check_name(node, name, name_range); end + + # A class emitter method is a singleton method in a class/module, where + # the method has the same name as a class defined in the class/module. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_formatting.rb:29 + def class_emitter_method?(node, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_formatting.rb:17 + def report_opposing_styles(node, name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_formatting.rb:23 + def valid_name?(node, name, given_style = T.unsafe(nil)); end +end + +# Handles `Max` configuration parameters, especially setting them to an +# appropriate value with --auto-gen-config. +# +# @deprecated Use `exclude_limit ParameterName` instead. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_max.rb:8 +module RuboCop::Cop::ConfigurableMax + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_max.rb:11 + def max=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_max.rb:19 + def max_parameter_name; end +end + +# This module provides functionality for checking if names match the +# configured EnforcedStyle. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_naming.rb:7 +module RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_naming.rb:10 +RuboCop::Cop::ConfigurableNaming::FORMATS = T.let(T.unsafe(nil), Hash) + +# This module provides functionality for checking if numbering match the +# configured EnforcedStyle. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_numbering.rb:7 +module RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/configurable_numbering.rb:11 +RuboCop::Cop::ConfigurableNumbering::FORMATS = T.let(T.unsafe(nil), Hash) + +# Legacy scaffold for Cops. +# See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html +# +# @deprecated Use Cop::Base instead +# +# source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:11 +class RuboCop::Cop::Cop < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:25 + def add_offense(node_or_range, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil), &block); end + + # @deprecated + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:60 + def corrections; end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:37 + def find_location(node, loc); end + + # Returns the value of attribute offenses. + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:12 + def offenses; end + + # Called after all on_... have been called + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:74 + def on_investigation_end; end + + # Called before all on_... have been called + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:68 + def on_new_investigation; end + + # @deprecated Use class method + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:43 + def support_autocorrect?; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:109 + def apply_correction(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:98 + def begin_investigation(processed_source); end + + # Override Base + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:105 + def callback_argument(_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:126 + def correction_lambda; end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:132 + def dedup_on_node(node); end + + # Just for legacy + # + # @yield [corrector] + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:114 + def emulate_v0_callsequence(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:139 + def suppress_clobbering; end + + class << self + # @deprecated Use Registry.all + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:87 + def all; end + + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:52 + def joining_forces; end + + # @deprecated Use Registry.qualified_cop_name + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:92 + def qualified_cop_name(name, origin); end + + # @deprecated Use Registry.global + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:82 + def registry; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:48 + def support_autocorrect?; end + end +end + +# @deprecated +# +# source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:17 +class RuboCop::Cop::Cop::Correction < ::Struct + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:18 + def call(corrector); end + + # Returns the value of attribute cop + # + # @return [Object] the current value of cop + def cop; end + + # Sets the attribute cop + # + # @param value [Object] the value to set the attribute cop to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:17 + def cop=(_); end + + # Returns the value of attribute lambda + # + # @return [Object] the current value of lambda + def lambda; end + + # Sets the attribute lambda + # + # @param value [Object] the value to set the attribute lambda to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:17 + def lambda=(_); end + + # Returns the value of attribute node + # + # @return [Object] the current value of node + def node; end + + # Sets the attribute node + # + # @param value [Object] the value to set the attribute node to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/cop.rb:17 + def node=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# This class takes a source buffer and rewrite its source +# based on the different correction rules supplied. +# +# Important! +# The nodes modified by the corrections should be part of the +# AST of the source_buffer. +# +# source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:11 +class RuboCop::Cop::Corrector < ::Parser::Source::TreeRewriter + # corrector = Corrector.new(cop) + # + # @param source [Parser::Source::Buffer, or anything + # leading to one via `(processed_source.)buffer`] + # @return [Corrector] a new instance of Corrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:18 + def initialize(source); end + + # Removes `size` characters from the beginning of the given range. + # If `size` is greater than the size of `range`, the removed region can + # overrun the end of `range`. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:49 + def remove_leading(node_or_range, size); end + + # Removes `size` characters prior to the source range. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:37 + def remove_preceding(node_or_range, size); end + + # Removes `size` characters from the end of the given range. + # If `size` is greater than the size of `range`, the removed region can + # overrun the beginning of `range`. + # + # @param range [Parser::Source::Range, RuboCop::AST::Node] or node + # @param size [Integer] + # + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:61 + def remove_trailing(node_or_range, size); end + + # Legacy + # + # source://parser-3.1.2.1/lib/parser/source/tree_rewriter.rb:252 + def rewrite; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:99 + def check_range_validity(node_or_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:84 + def to_range(node_or_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:103 + def validate_buffer(buffer); end + + class << self + # Duck typing for get to a ::Parser::Source::Buffer + # + # source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:68 + def source_buffer(source); end + end +end + +# noop +# +# source://rubocop-1.35.1/lib/rubocop/cop/corrector.rb:12 +RuboCop::Cop::Corrector::NOOP_CONSUMER = T.let(T.unsafe(nil), Proc) + +# Common functionality for checking def nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/def_node.rb:6 +module RuboCop::Cop::DefNode + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/def_node.rb:21 + def non_public_modifier?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/def_node.rb:12 + def non_public?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/def_node.rb:16 + def preceding_non_public_modifier?(node); end +end + +# Helpers for builtin documentation +# +# source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:6 +module RuboCop::Cop::Documentation + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:24 + def base_url_for(cop_class, config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:34 + def default_base_url; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:10 + def department_to_basename(department); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:15 + def url_for(cop_class, config = T.unsafe(nil)); end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:24 + def base_url_for(cop_class, config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:34 + def default_base_url; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:10 + def department_to_basename(department); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/documentation.rb:15 + def url_for(cop_class, config = T.unsafe(nil)); end + end +end + +# Common functionality for checking documentation. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:6 +module RuboCop::Cop::DocumentationComment + extend ::RuboCop::AST::NodePattern::Macros + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:47 + def annotation_keywords; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:11 + def documentation_comment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:39 + def interpreter_directive_comment?(comment); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:31 + def precede?(node1, node2); end + + # The args node1 & node2 may represent a RuboCop::AST::Node + # or a Parser::Source::Comment. Both respond to #loc. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:25 + def preceding_comment?(node1, node2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:35 + def preceding_lines(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/documentation_comment.rb:43 + def rubocop_directive_comment?(comment); end +end + +# Common functionality for dealing with duplication. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/duplication.rb:6 +module RuboCop::Cop::Duplication + private + + # Returns the consecutive duplicates, leaving out the first instance of + # the duplicated elements. + # + # @param collection [Array] an array to return consecutive duplicates for + # @return [Array] the consecutive duplicates + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/duplication.rb:31 + def consecutive_duplicates(collection); end + + # Returns all duplicates, including the first instance of the duplicated + # elements. + # + # @param collection [Array] an array to return duplicates for + # @return [Array] all the duplicates + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/duplication.rb:22 + def duplicates(collection); end + + # Whether the `collection` contains any duplicates. + # + # @param collection [Array] an array to check for duplicates + # @return [Boolean] whether the array contains any duplicates + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/duplication.rb:13 + def duplicates?(collection); end + + # Returns a hash of grouped duplicates. The key will be the first + # instance of the element, and the value an `array` of the initial + # element and all duplicate instances. + # + # @param collection [Array] an array to group duplicates for + # @return [Array] the grouped duplicates + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/duplication.rb:41 + def grouped_duplicates(collection); end +end + +# This class autocorrects `#each` enumeration to `for` iteration. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:6 +class RuboCop::Cop::EachToForCorrector + extend ::RuboCop::AST::NodePattern::Macros + + # @return [EachToForCorrector] a new instance of EachToForCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:12 + def initialize(block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:18 + def call(corrector); end + + private + + # Returns the value of attribute argument_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + def argument_node; end + + # Returns the value of attribute block_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + def block_node; end + + # Returns the value of attribute collection_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + def collection_node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:26 + def correction; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:36 + def offending_range; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:44 + def replacement_range(end_pos); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:10 +RuboCop::Cop::EachToForCorrector::CORRECTION_WITHOUT_ARGUMENTS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/each_to_for_corrector.rb:9 +RuboCop::Cop::EachToForCorrector::CORRECTION_WITH_ARGUMENTS = T.let(T.unsafe(nil), String) + +# This class does empty line autocorrection +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/empty_line_corrector.rb:6 +class RuboCop::Cop::EmptyLineCorrector + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/empty_line_corrector.rb:8 + def correct(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/empty_line_corrector.rb:19 + def insert_before(corrector, node); end + end +end + +# Common code for empty parameter cops. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_parameter.rb:6 +module RuboCop::Cop::EmptyParameter + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_parameter.rb:12 + def empty_arguments?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_parameter.rb:16 + def check(node); end +end + +# Functions for checking the alignment of the `end` keyword. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:6 +module RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:60 + def accept_end_kw_alignment?(end_loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:50 + def add_offense_for_misalignment(node, align_with); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:19 + def check_end_kw_alignment(node, align_ranges); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:15 + def check_end_kw_in_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:75 + def line_break_before_keyword?(whole_expression, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:35 + def matching_ranges(end_loc, align_ranges); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:41 + def start_line_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:65 + def style_parameter_name; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:69 + def variable_alignment?(whole_expression, rhs, end_alignment_style); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/end_keyword_alignment.rb:10 +RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for enforcing a specific superclass. +# +# IMPORTANT: RuboCop core depended on this module when it supported Rails department. +# Rails department has been extracted to RuboCop Rails gem. +# +# It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility +# with existing RuboCop Rails 2.8 or lower. +# +# @api private +# @deprecated This module is deprecated and will be removed by RuboCop 2.0. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/enforce_superclass.rb:15 +module RuboCop::Cop::EnforceSuperclass + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/enforce_superclass.rb:35 + def on_class(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/enforce_superclass.rb:39 + def on_send(node); end + + class << self + # @api private + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/enforce_superclass.rb:16 + def included(base); end + end +end + +# Common functionality for checking for a line break before the first +# element in a multi-line collection. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:7 +module RuboCop::Cop::FirstElementLineBreak + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:23 + def check_children_line_break(node, children, start = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:10 + def check_method_line_break(node, children); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:37 + def first_by_line(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:41 + def last_by_line(nodes); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/first_element_line_break.rb:18 + def method_uses_parens?(node, limit); end +end + +# This class autocorrects `for` iteration to `#each` enumeration. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:6 +class RuboCop::Cop::ForToEachCorrector + extend ::RuboCop::AST::NodePattern::Macros + + # @return [ForToEachCorrector] a new instance of ForToEachCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:11 + def initialize(for_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:17 + def call(corrector); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:55 + def collection_end; end + + # Returns the value of attribute collection_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:23 + def collection_node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:29 + def collection_source; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:25 + def correction; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:43 + def end_position; end + + # Returns the value of attribute for_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:23 + def for_node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:51 + def keyword_begin; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:63 + def offending_range; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:67 + def replacement_range(end_pos); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:37 + def requires_parentheses?; end + + # Returns the value of attribute variable_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:23 + def variable_node; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/for_to_each_corrector.rb:9 +RuboCop::Cop::ForToEachCorrector::CORRECTION = T.let(T.unsafe(nil), String) + +# A scaffold for concrete forces. +# +# source://rubocop-1.35.1/lib/rubocop/cop/force.rb:6 +class RuboCop::Cop::Force + # @return [Force] a new instance of Force + # + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:22 + def initialize(cops); end + + # Returns the value of attribute cops. + # + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:7 + def cops; end + + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:38 + def investigate(_processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:26 + def name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:30 + def run_hook(method_name, *args); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:9 + def all; end + + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:18 + def force_name; end + + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cop/force.rb:13 + def inherited(subclass); end + end +end + +# Common functionality for dealing with frozen string literals. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:6 +module RuboCop::Cop::FrozenStringLiteral + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:35 + def frozen_heredoc?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:21 + def frozen_string_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:15 + def frozen_string_literal_comment_exists?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:66 + def frozen_string_literal_specified?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:60 + def frozen_string_literals_disabled?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:41 + def frozen_string_literals_enabled?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:72 + def leading_comment_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:31 + def uninterpolated_string?(node); end + + class << self + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:15 + def frozen_string_literal_comment_exists?; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:9 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:10 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_ENABLED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/frozen_string_literal.rb:11 +RuboCop::Cop::FrozenStringLiteral::FROZEN_STRING_LITERAL_TYPES_RUBY27 = T.let(T.unsafe(nil), Array) + +# Common functionality for checking gem declarations. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/gem_declaration.rb:6 +module RuboCop::Cop::GemDeclaration + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/gem_declaration.rb:10 + def gem_declaration?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:5 +module RuboCop::Cop::Gemspec; end + +# Enforce that gem dependency version specifications or a commit reference (branch, +# ref, or tag) are either required or forbidden. +# +# @example EnforcedStyle: required (default) +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# @example EnforcedStyle: forbidden +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser', '>= 2.3.3.1', '< 3.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_dependency 'parser' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_development_dependency 'parser' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:53 +class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:62 + def add_dependency_method_declarations(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:73 + def includes_commit_reference?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:68 + def includes_version_specification?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:77 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:118 + def add_dependency_method?(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:122 + def add_dependency_method_nodes; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:94 + def allowed_gem?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:98 + def allowed_gems; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:136 + def forbidden_offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:142 + def forbidden_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:112 + def match_block_variable_name?(receiver_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:102 + def message(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:126 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:130 + def required_offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:146 + def required_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:150 + def version_specification?(expression); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:58 +RuboCop::Cop::Gemspec::DependencyVersion::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:57 +RuboCop::Cop::Gemspec::DependencyVersion::REQUIRED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/dependency_version.rb:59 +RuboCop::Cop::Gemspec::DependencyVersion::VERSION_SPECIFICATION_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks that deprecated attribute attributes are not set in a gemspec file. +# Removing deprecated attributes allows the user to receive smaller packed gems. +# +# @example +# +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# spec.test_files = Dir.glob('test/**/*') +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# spec.test_files += Dir.glob('test/**/*') +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.name = 'your_cool_gem_name' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:28 +class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:35 + def gem_specification(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:43 + def on_block(block_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:86 + def format_message_from; end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:63 + def node_and_method_name(node, attribute); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:72 + def use_deprecated_attributes?(node, block_parameter); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/deprecated_attribute_assignment.rb:32 +RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::MSG = T.let(T.unsafe(nil), String) + +# An attribute assignment method calls should be listed only once +# in a gemspec. +# +# Assigning to an attribute with the same name using `spec.foo =` will be +# an unintended usage. On the other hand, duplication of methods such +# as `spec.requirements`, `spec.add_runtime_dependency`, and others are +# permitted because it is the intended use of appending values. +# +# @example +# # bad +# Gem::Specification.new do |spec| +# spec.name = 'rubocop' +# spec.name = 'rubocop2' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.name = 'rubocop' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.requirements << 'libmagick, v6.0' +# spec.requirements << 'A good graphics card' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_runtime_dependency('parallel', '~> 1.10') +# spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0') +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:37 +class RuboCop::Cop::Gemspec::DuplicatedAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:45 + def assignment_method_declarations(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:50 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:68 + def duplicated_assignment_method_nodes; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:62 + def match_block_variable_name?(receiver_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:76 + def register_offense(node, assignment, line_of_first_occurrence); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/duplicated_assignment.rb:41 +RuboCop::Cop::Gemspec::DuplicatedAssignment::MSG = T.let(T.unsafe(nil), String) + +# Dependencies in the gemspec should be alphabetically sorted. +# +# @example +# # bad +# spec.add_dependency 'rubocop' +# spec.add_dependency 'rspec' +# +# # good +# spec.add_dependency 'rspec' +# spec.add_dependency 'rubocop' +# +# # good +# spec.add_dependency 'rubocop' +# +# spec.add_dependency 'rspec' +# +# # bad +# spec.add_development_dependency 'rubocop' +# spec.add_development_dependency 'rspec' +# +# # good +# spec.add_development_dependency 'rspec' +# spec.add_development_dependency 'rubocop' +# +# # good +# spec.add_development_dependency 'rubocop' +# +# spec.add_development_dependency 'rspec' +# +# # bad +# spec.add_runtime_dependency 'rubocop' +# spec.add_runtime_dependency 'rspec' +# +# # good +# spec.add_runtime_dependency 'rspec' +# spec.add_runtime_dependency 'rubocop' +# +# # good +# spec.add_runtime_dependency 'rubocop' +# +# spec.add_runtime_dependency 'rspec' +# +# # good only if TreatCommentsAsGroupSeparators is true +# # For code quality +# spec.add_dependency 'rubocop' +# # For tests +# spec.add_dependency 'rspec' +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:53 +class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:87 + def dependency_declarations(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:61 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:82 + def get_dependency_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:76 + def previous_declaration(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ordered_dependencies.rb:57 +RuboCop::Cop::Gemspec::OrderedDependencies::MSG = T.let(T.unsafe(nil), String) + +# Requires a gemspec to have `rubygems_mfa_required` metadata set. +# +# This setting tells RubyGems that MFA (Multi-Factor Authentication) is +# required for accounts to be able perform privileged operations, such as +# (see RubyGems' documentation for the full list of privileged +# operations): +# +# * `gem push` +# * `gem yank` +# * `gem owner --add/remove` +# * adding or removing owners using gem ownership page +# +# This helps make your gem more secure, as users can be more +# confident that gem updates were pushed by maintainers. +# +# @example +# # bad +# Gem::Specification.new do |spec| +# # no `rubygems_mfa_required` metadata specified +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'true' +# } +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'true' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'false' +# } +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata = { +# 'rubygems_mfa_required' => 'true' +# } +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'false' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.metadata['rubygems_mfa_required'] = 'true' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:63 +class RuboCop::Cop::Gemspec::RequireMFA < ::RuboCop::Cop::Base + include ::RuboCop::Cop::GemspecHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:70 + def metadata(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:87 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:78 + def rubygems_mfa_required(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:83 + def true_string?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:115 + def autocorrect(corrector, node, block_var, metadata); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:139 + def change_value(corrector, value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:125 + def correct_metadata(corrector, metadata); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:133 + def insert_mfa_required(corrector, node, block_var); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:108 + def mfa_value(metadata_value); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/require_mfa.rb:67 +RuboCop::Cop::Gemspec::RequireMFA::MSG = T.let(T.unsafe(nil), String) + +# Checks that `required_ruby_version` in a gemspec file is set to a valid +# value (non-blank) and matches `TargetRubyVersion` as set in RuboCop's +# configuration for the gem. +# +# This ensures that RuboCop is using the same Ruby version as the gem. +# +# @example +# # When `TargetRubyVersion` of .rubocop.yml is `2.5`. +# +# # bad +# Gem::Specification.new do |spec| +# # no `required_ruby_version` specified +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.4.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.6.0' +# end +# +# # bad +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.5.0' +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '>= 2.5' +# end +# +# # accepted but not recommended +# Gem::Specification.new do |spec| +# spec.required_ruby_version = ['>= 2.5.0', '< 2.7.0'] +# end +# +# # accepted but not recommended, since +# # Ruby does not really follow semantic versioning +# Gem::Specification.new do |spec| +# spec.required_ruby_version = '~> 2.5' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:55 +class RuboCop::Cop::Gemspec::RequiredRubyVersion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:70 + def defined_ruby_version(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:78 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:82 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:65 + def required_ruby_version?(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:94 + def dynamic_version?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:100 + def extract_ruby_version(required_ruby_version); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:116 + def not_equal_message(required_ruby_version, target_ruby_version); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:62 +RuboCop::Cop::Gemspec::RequiredRubyVersion::MISSING_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:59 +RuboCop::Cop::Gemspec::RequiredRubyVersion::NOT_EQUAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/required_ruby_version.rb:58 +RuboCop::Cop::Gemspec::RequiredRubyVersion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks that `RUBY_VERSION` constant is not used in gemspec. +# Using `RUBY_VERSION` is dangerous because value of the +# constant is determined by `rake release`. +# It's possible to have dependency based on ruby version used +# to execute `rake release` and not user's ruby version. +# +# @example +# +# # bad +# Gem::Specification.new do |spec| +# if RUBY_VERSION >= '3.0' +# spec.add_runtime_dependency 'gem_a' +# else +# spec.add_runtime_dependency 'gem_b' +# end +# end +# +# # good +# Gem::Specification.new do |spec| +# spec.add_runtime_dependency 'gem_a' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb:28 +class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage < ::RuboCop::Cop::Base + include ::RuboCop::Cop::GemspecHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb:36 + def on_const(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb:34 + def ruby_version?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb:44 + def gem_spec_with_ruby_version?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb:31 +RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking gem declarations. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/gemspec_help.rb:6 +module RuboCop::Cop::GemspecHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/gemspec_help.rb:20 + def gem_specification(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/gemspec_help.rb:10 + def gem_specification?(param0 = T.unsafe(nil)); end +end + +# Source and spec generator for new cops +# +# This generator will take a cop name and generate a source file +# and spec file when given a valid qualified cop name. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:10 +class RuboCop::Cop::Generator + # @api private + # @raise [ArgumentError] + # @return [Generator] a new instance of Generator + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:113 + def initialize(name, output: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:133 + def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:129 + def inject_require(root_file_path: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:146 + def todo; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:121 + def write_source; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:125 + def write_spec; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:160 + def badge; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:183 + def generate(template); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:175 + def generated_source; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:179 + def generated_spec; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:160 + def output; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:208 + def snake_case(camel_case_string); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:198 + def source_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:188 + def spec_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:162 + def write_unless_file_exists(path, contents); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:109 +RuboCop::Cop::Generator::CONFIGURATION_ADDED_MESSAGE = T.let(T.unsafe(nil), String) + +# A class that injects a require directive into the root RuboCop file. +# It looks for other directives that require files in the same (cop) +# namespace and injects the provided one in alpha +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:9 +class RuboCop::Cop::Generator::ConfigurationInjector + # @api private + # @return [ConfigurationInjector] a new instance of ConfigurationInjector + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:17 + def initialize(configuration_file_path:, badge:, version_added: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:24 + def inject; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:39 + def badge; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:41 + def configuration_entries; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:39 + def configuration_file_path; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:59 + def cop_name_line?(yaml); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:49 + def find_target_line; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:45 + def new_configuration_entry; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:39 + def output; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:39 + def version_added; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator/configuration_injector.rb:10 +RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String) + +# A class that injects a require directive into the root RuboCop file. +# It looks for other directives that require files in the same (cop) +# namespace and injects the provided one in alpha +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:9 +class RuboCop::Cop::Generator::RequireFileInjector + # @api private + # @return [RequireFileInjector] a new instance of RequireFileInjector + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:12 + def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:19 + def inject; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:64 + def injectable_require_directive; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:29 + def output; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:29 + def require_entries; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:31 + def require_exists?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:68 + def require_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:58 + def require_path_fragments(require_directive); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:29 + def root_file_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:29 + def source_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:39 + def target_line; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:35 + def updated_directives; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator/require_file_injector.rb:10 +RuboCop::Cop::Generator::RequireFileInjector::REQUIRE_PATH = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:11 +RuboCop::Cop::Generator::SOURCE_TEMPLATE = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/generator.rb:85 +RuboCop::Cop::Generator::SPEC_TEMPLATE = T.let(T.unsafe(nil), String) + +# Common functionality for checking hash alignment. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:6 +module RuboCop::Cop::HashAlignmentStyles; end + +# Handles calculation of deltas when the enforced style is 'key'. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:8 +class RuboCop::Cop::HashAlignmentStyles::KeyAlignment + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:9 + def checkable_layout?(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:20 + def deltas(first_pair, current_pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:13 + def deltas_for_first_pair(first_pair, _node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:34 + def separator_delta(pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:45 + def value_delta(pair); end +end + +# Handles calculation of deltas for `kwsplat` nodes. +# This is a special case that just ensures the kwsplat is aligned with the rest of the hash +# since a `kwsplat` does not have a key, separator or value. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:145 +class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:146 + def deltas(first_pair, current_pair); end +end + +# Handles calculation of deltas when the enforced style is 'separator'. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:120 +class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:123 + def deltas_for_first_pair(*_nodes); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:133 + def hash_rocket_delta(first_pair, current_pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:129 + def key_delta(first_pair, current_pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:137 + def value_delta(first_pair, current_pair); end +end + +# Handles calculation of deltas when the enforced style is 'table'. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:81 +class RuboCop::Cop::HashAlignmentStyles::TableAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + + # @return [TableAlignment] a new instance of TableAlignment + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:84 + def initialize; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:88 + def deltas_for_first_pair(first_pair, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:106 + def hash_rocket_delta(first_pair, current_pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:102 + def key_delta(first_pair, current_pair); end + + # Returns the value of attribute max_key_width. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:100 + def max_key_width; end + + # Sets the attribute max_key_width + # + # @param value the value to set the attribute max_key_width to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:100 + def max_key_width=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:110 + def value_delta(first_pair, current_pair); end +end + +# Common functionality for checking alignment of hash values. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:56 +module RuboCop::Cop::HashAlignmentStyles::ValueAlignment + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:57 + def checkable_layout?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:61 + def deltas(first_pair, current_pair); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_alignment_styles.rb:71 + def separator_delta(first_pair, current_pair, key_delta); end +end + +# This module checks for Ruby 3.1's hash value omission syntax. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:6 +module RuboCop::Cop::HashShorthandSyntax + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:13 + def on_hash_for_mixed_shorthand(hash_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:25 + def on_pair(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:106 + def breakdown_value_types_of_hash(hash_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:130 + def each_omittable_value_pair(hash_value_type_breakdown, &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:126 + def each_omitted_value_pair(hash_value_type_breakdown, &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:65 + def enforced_shorthand_syntax; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:118 + def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:122 + def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:59 + def ignore_hash_shorthand_syntax?(pair_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:54 + def ignore_mixed_hash_shorthand_syntax?(hash_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:134 + def mixed_shorthand_syntax_check(hash_value_type_breakdown); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:150 + def no_mixed_shorthand_syntax_check(hash_value_type_breakdown); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:48 + def register_offense(node, message, replacement); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:69 + def require_hash_value?(hash_key_source, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:78 + def require_hash_value_for_around_hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:87 + def use_element_of_hash_literal_as_receiver?(ancestor, parent); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:92 + def use_modifier_form_without_parenthesized_method_call?(ancestor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:98 + def without_parentheses_call_expr_follows?(ancestor); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:11 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_EXPLICIT_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:9 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_MSG_PREFIX = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:10 +RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_OMIT_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:8 +RuboCop::Cop::HashShorthandSyntax::EXPLICIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:7 +RuboCop::Cop::HashShorthandSyntax::OMIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) + +# Common functionality for Style/HashTransformKeys and +# Style/HashTransformValues +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:7 +module RuboCop::Cop::HashTransformMethod + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:13 + def array_receiver?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:17 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:34 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:27 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:106 + def execute_correction(corrector, node, correction); end + + # @abstract + # @raise [NotImplementedError] + # @return [Captures] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:81 + def extract_captures(_match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:60 + def handle_possible_offense(node, match, match_desc); end + + # @abstract + # @raise [NotImplementedError] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:88 + def new_method_name; end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:41 + def on_bad_each_with_object(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:46 + def on_bad_hash_brackets_map(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:51 + def on_bad_map_to_h(_node); end + + # @abstract Implemented with `def_node_matcher` + # @raise [NotImplementedError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:56 + def on_bad_to_h(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:92 + def prepare_correction(node); end +end + +# Internal helper class to hold autocorrect data +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:132 +class RuboCop::Cop::HashTransformMethod::Autocorrection < ::Struct + # Returns the value of attribute block_node + # + # @return [Object] the current value of block_node + def block_node; end + + # Sets the attribute block_node + # + # @param value [Object] the value to set the attribute block_node to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:132 + def block_node=(_); end + + # Returns the value of attribute leading + # + # @return [Object] the current value of leading + def leading; end + + # Sets the attribute leading + # + # @param value [Object] the value to set the attribute leading to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:132 + def leading=(_); end + + # Returns the value of attribute match + # + # @return [Object] the current value of match + def match; end + + # Sets the attribute match + # + # @param value [Object] the value to set the attribute match to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:132 + def match=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:173 + def set_new_arg_name(transformed_argname, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:177 + def set_new_body_expression(transforming_body_expr, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:163 + def set_new_method_name(new_method_name, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:157 + def strip_prefix_and_suffix(node, corrector); end + + # Returns the value of attribute trailing + # + # @return [Object] the current value of trailing + def trailing; end + + # Sets the attribute trailing + # + # @param value [Object] the value to set the attribute trailing to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:132 + def trailing=(_); end + + class << self + def [](*_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:133 + def from_each_with_object(node, match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:137 + def from_hash_brackets_map(node, match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:141 + def from_map_to_h(node, match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:153 + def from_to_h(node, match); end + + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Internal helper class to hold match data +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:116 +class RuboCop::Cop::HashTransformMethod::Captures < ::Struct + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:121 + def noop_transformation?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:126 + def transformation_uses_both_args?; end + + # Returns the value of attribute transformed_argname + # + # @return [Object] the current value of transformed_argname + def transformed_argname; end + + # Sets the attribute transformed_argname + # + # @param value [Object] the value to set the attribute transformed_argname to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:116 + def transformed_argname=(_); end + + # Returns the value of attribute transforming_body_expr + # + # @return [Object] the current value of transforming_body_expr + def transforming_body_expr; end + + # Sets the attribute transforming_body_expr + # + # @param value [Object] the value to set the attribute transforming_body_expr to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:116 + def transforming_body_expr=(_); end + + # Returns the value of attribute unchanged_body_expr + # + # @return [Object] the current value of unchanged_body_expr + def unchanged_body_expr; end + + # Sets the attribute unchanged_body_expr + # + # @param value [Object] the value to set the attribute unchanged_body_expr to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:116 + def unchanged_body_expr=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/hash_transform_method.rb:10 +RuboCop::Cop::HashTransformMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Common functionality for working with heredoc strings. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:6 +module RuboCop::Cop::Heredoc + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:9 + def on_dstr(node); end + + # @raise [NotImplementedError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:17 + def on_heredoc(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:9 + def on_str(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:9 + def on_xstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:28 + def delimiter_string(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:32 + def heredoc_type(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:23 + def indent_level(str); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/heredoc.rb:7 +RuboCop::Cop::Heredoc::OPENING_DELIMITER = T.let(T.unsafe(nil), Regexp) + +# This class autocorrects `if...then` structures to a multiline `if` statement +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:6 +class RuboCop::Cop::IfThenCorrector + # @return [IfThenCorrector] a new instance of IfThenCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:9 + def initialize(if_node, indentation: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:14 + def call(corrector); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:50 + def branch_body_indentation; end + + # Returns the value of attribute if_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:20 + def if_node; end + + # Returns the value of attribute indentation. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:20 + def indentation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:22 + def replacement(node = T.unsafe(nil), indentation = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:36 + def rewrite_else_branch(else_branch, indentation); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/if_then_corrector.rb:7 +RuboCop::Cop::IfThenCorrector::DEFAULT_INDENTATION_WIDTH = T.let(T.unsafe(nil), Integer) + +# @deprecated IgnoredMethods class has been replaced with AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_methods.rb:33 +RuboCop::Cop::IgnoredMethods = RuboCop::Cop::AllowedMethods + +# Handles adding and checking ignored nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/ignored_node.rb:6 +module RuboCop::Cop::IgnoredNode + # source://rubocop-1.35.1/lib/rubocop/cop/ignored_node.rb:7 + def ignore_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/ignored_node.rb:24 + def ignored_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/ignored_node.rb:11 + def part_of_ignored_node?(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/ignored_node.rb:31 + def ignored_nodes; end +end + +# @deprecated IgnoredPattern class has been replaced with AllowedPattern. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/allowed_pattern.rb:46 +RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern + +# Common functionality for checking integer nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/integer_node.rb:6 +module RuboCop::Cop::IntegerNode + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/integer_node.rb:9 + def integer_part(node); end +end + +# Common functionality for working with string interpolations. +# +# @abstract Subclasses are expected to implement {#on_interpolation}. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:8 +module RuboCop::Cop::Interpolation + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:9 + def on_dstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:9 + def on_dsym(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:17 + def on_node_with_interpolations(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:9 + def on_regexp(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/interpolation.rb:9 + def on_xstr(node); end +end + +# This class autocorrects lambda literal to method notation. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:6 +class RuboCop::Cop::LambdaLiteralToMethodCorrector + # @return [LambdaLiteralToMethodCorrector] a new instance of LambdaLiteralToMethodCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:7 + def initialize(block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:13 + def call(corrector); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:115 + def arg_to_unparenthesized_call?; end + + # Returns the value of attribute arguments. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:31 + def arguments; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:99 + def arguments_begin_pos; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:95 + def arguments_end_pos; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:107 + def block_begin; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:103 + def block_end; end + + # Returns the value of attribute block_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:31 + def block_node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:56 + def insert_arguments(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:40 + def insert_separating_space(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:85 + def lambda_arg_string; end + + # Returns the value of attribute method. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:31 + def method; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:89 + def needs_separating_space?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:50 + def remove_arguments(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:63 + def remove_leading_whitespace(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:71 + def remove_trailing_whitespace(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:33 + def remove_unparenthesized_whitespace(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:76 + def replace_delimiters(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:46 + def replace_selector(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:111 + def selector_end; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:131 + def separating_space?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:5 +module RuboCop::Cop::Layout; end + +# Bare access modifiers (those not applying to specific methods) should be +# indented as deep as method definitions, or as deep as the class/module +# keyword, depending on configuration. +# +# @example EnforcedStyle: indent (default) +# # bad +# class Plumbus +# private +# def smooth; end +# end +# +# # good +# class Plumbus +# private +# def smooth; end +# end +# @example EnforcedStyle: outdent +# # bad +# class Plumbus +# private +# def smooth; end +# end +# +# # good +# class Plumbus +# private +# def smooth; end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:35 +class RuboCop::Cop::Layout::AccessModifierIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:43 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:43 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:43 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:43 + def on_sclass(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:54 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:58 + def check_body(body, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:65 + def check_modifier(send_node, end_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:88 + def expected_indent_offset; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:84 + def message(range); end + + # An offset that is not expected, but correct if the configuration is + # changed. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:94 + def unexpected_indent_offset; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/access_modifier_indentation.rb:41 +RuboCop::Cop::Layout::AccessModifierIndentation::MSG = T.let(T.unsafe(nil), String) + +# Here we check if the arguments on a multi-line method +# definition are aligned. +# +# @example EnforcedStyle: with_first_argument (default) +# # good +# +# foo :bar, +# :baz, +# key: value +# +# foo( +# :bar, +# :baz, +# key: value +# ) +# +# # bad +# +# foo :bar, +# :baz, +# key: value +# +# foo( +# :bar, +# :baz, +# key: value +# ) +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# foo :bar, +# :baz, +# key: value +# +# # bad +# +# foo :bar, +# :baz, +# key: value +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:46 +class RuboCop::Cop::Layout::ArgumentAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:55 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:55 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:92 + def arguments_or_first_arg_pairs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:80 + def arguments_with_last_arg_pairs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:108 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:68 + def autocorrect_incompatible_with_other_cops?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:124 + def base_column(node, first_argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:144 + def enforce_hash_argument_with_separator?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:116 + def fixed_indentation?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:72 + def flattened_arguments(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:152 + def hash_argument_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:112 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:101 + def multiple_arguments?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:135 + def target_method_lineno(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:120 + def with_first_argument_style?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:50 +RuboCop::Cop::Layout::ArgumentAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/argument_alignment.rb:52 +RuboCop::Cop::Layout::ArgumentAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Here we check if the elements of a multi-line array literal are +# aligned. +# +# @example EnforcedStyle: with_first_element (default) +# # good +# +# array = [1, 2, 3, +# 4, 5, 6] +# array = ['run', +# 'forrest', +# 'run'] +# +# # bad +# +# array = [1, 2, 3, +# 4, 5, 6] +# array = ['run', +# 'forrest', +# 'run'] +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# array = [1, 2, 3, +# 4, 5, 6] +# +# # bad +# +# array = [1, 2, 3, +# 4, 5, 6] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:36 +class RuboCop::Cop::Layout::ArrayAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:46 + def on_array(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:55 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:67 + def base_column(node, args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:63 + def fixed_indentation?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:59 + def message(_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:78 + def target_method_lineno(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:40 +RuboCop::Cop::Layout::ArrayAlignment::ALIGN_ELEMENTS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/array_alignment.rb:43 +RuboCop::Cop::Layout::ArrayAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first line of the +# right-hand-side of a multi-line assignment. +# +# The indentation of the remaining lines can be corrected with +# other cops such as `IndentationConsistency` and `EndAlignment`. +# +# @example +# # bad +# value = +# if foo +# 'bar' +# end +# +# # good +# value = +# if foo +# 'bar' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/assignment_indentation.rb:24 +class RuboCop::Cop::Layout::AssignmentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/assignment_indentation.rb:42 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/assignment_indentation.rb:33 + def check_assignment(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/assignment_indentation.rb:46 + def leftmost_multiple_assignment(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/assignment_indentation.rb:29 +RuboCop::Cop::Layout::AssignmentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keyword of `begin` is aligned properly. +# +# Two modes are supported through the `EnforcedStyleAlignWith` configuration +# parameter. If it's set to `start_of_line` (which is the default), the +# `end` shall be aligned with the start of the line where the `begin` +# keyword is. If it's set to `begin`, the `end` shall be aligned with the +# `begin` keyword. +# +# `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`) +# by default. On the other hand, `||= begin` that this cop targets tends to +# align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`. +# These style can be configured by each cop. +# +# @example EnforcedStyleAlignWith: start_of_line (default) +# # bad +# foo ||= begin +# do_something +# end +# +# # good +# foo ||= begin +# do_something +# end +# @example EnforcedStyleAlignWith: begin +# # bad +# foo ||= begin +# do_something +# end +# +# # good +# foo ||= begin +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:41 +class RuboCop::Cop::Layout::BeginEndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:48 + def on_kwbegin(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:63 + def alignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:59 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:54 + def check_begin_alignment(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/begin_end_alignment.rb:46 +RuboCop::Cop::Layout::BeginEndAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords are aligned properly for do +# end blocks. +# +# Three modes are supported through the `EnforcedStyleAlignWith` +# configuration parameter: +# +# `start_of_block` : the `end` shall be aligned with the +# start of the line where the `do` appeared. +# +# `start_of_line` : the `end` shall be aligned with the +# start of the line where the expression started. +# +# `either` (which is the default) : the `end` is allowed to be in either +# location. The autofixer will default to `start_of_line`. +# +# @example EnforcedStyleAlignWith: either (default) +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# variable = lambda do |i| +# i +# end +# @example EnforcedStyleAlignWith: start_of_block +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# foo.bar +# .each do +# baz +# end +# @example EnforcedStyleAlignWith: start_of_line +# # bad +# +# foo.bar +# .each do +# baz +# end +# +# # good +# +# foo.bar +# .each do +# baz +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:64 +class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:72 + def block_end_align_target?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:81 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:81 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:87 + def style_parameter_name; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:226 + def add_space_before(corrector, loc, delta); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:203 + def alt_start_msg(start_loc, source_line_column); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:153 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:103 + def block_end_align_target(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:121 + def check_block_alignment(start_node, block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:176 + def compute_do_source_line_column(node, end_loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:218 + def compute_start_col(ancestor_node, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:117 + def disqualified_parent?(parent, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:113 + def end_align_target?(node, parent); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:166 + def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:213 + def format_source_line_column(source_line_column); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:195 + def loc_to_source_line_column(loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:134 + def register_offense(block_node, start_loc, end_loc, do_source_line_column); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:230 + def remove_space_before(corrector, end_pos, delta); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:93 + def start_for_block_node(block_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/block_alignment.rb:69 +RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end statement of a do..end block +# is on its own line. +# +# @example +# # bad +# blah do |i| +# foo(i) end +# +# # good +# blah do |i| +# foo(i) +# end +# +# # bad +# blah { |i| +# foo(i) } +# +# # good +# blah { |i| +# foo(i) +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:27 +class RuboCop::Cop::Layout::BlockEndNewline < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:33 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:33 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:82 + def end_of_method_chain(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:64 + def last_heredoc_argument(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:60 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:74 + def offense_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:46 + def register_offense(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/block_end_newline.rb:31 +RuboCop::Cop::Layout::BlockEndNewline::MSG = T.let(T.unsafe(nil), String) + +# Checks how the `when` and ``in``s of a `case` expression +# are indented in relation to its `case` or `end` keyword. +# +# It will register a separate offense for each misaligned `when` and `in`. +# +# @example +# # If Layout/EndAlignment is set to keyword style (default) +# # *case* and *end* should always be aligned to same depth, +# # and therefore *when* should always be aligned to both - +# # regardless of configuration. +# +# # bad for all styles +# case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good for all styles +# case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# @example EnforcedStyle: case (default) +# # if EndAlignment is set to other style such as +# # start_of_line (as shown below), then *when* alignment +# # configuration does have an effect. +# +# # bad +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# @example EnforcedStyle: end +# # bad +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# # good +# a = case n +# when 0 +# x * 2 +# else +# y / 3 +# end +# +# a = case n +# in pattern +# x * 2 +# else +# y / 3 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:112 +class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:120 + def on_case(case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:127 + def on_case_match(case_match_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:193 + def base_column(case_node, base); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:150 + def check_when(when_node, branch_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:182 + def detect_incorrect_style(when_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:136 + def end_and_last_conditional_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:146 + def enforced_style_end?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:169 + def incorrect_style(when_node, branch_type); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:161 + def indent_one_step?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:165 + def indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:207 + def replacement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:200 + def whitespace_range(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/case_indentation.rb:118 +RuboCop::Cop::Layout::CaseIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks if the code style follows the ExpectedOrder configuration: +# +# `Categories` allows us to map macro names into a category. +# +# Consider an example of code style that covers the following order: +# +# * Module inclusion (include, prepend, extend) +# * Constants +# * Associations (has_one, has_many) +# * Public attribute macros (attr_accessor, attr_writer, attr_reader) +# * Other macros (validates, validate) +# * Public class methods +# * Initializer +# * Public instance methods +# * Protected attribute macros (attr_accessor, attr_writer, attr_reader) +# * Protected instance methods +# * Private attribute macros (attr_accessor, attr_writer, attr_reader) +# * Private instance methods +# +# You can configure the following order: +# +# [source,yaml] +# ---- +# Layout/ClassStructure: +# ExpectedOrder: +# - module_inclusion +# - constants +# - association +# - public_attribute_macros +# - public_delegate +# - macros +# - public_class_methods +# - initializer +# - public_methods +# - protected_attribute_macros +# - protected_methods +# - private_attribute_macros +# - private_delegate +# - private_methods +# ---- +# +# Instead of putting all literals in the expected order, is also +# possible to group categories of macros. Visibility levels are handled +# automatically. +# +# [source,yaml] +# ---- +# Layout/ClassStructure: +# Categories: +# association: +# - has_many +# - has_one +# attribute_macros: +# - attr_accessor +# - attr_reader +# - attr_writer +# macros: +# - validates +# - validate +# module_inclusion: +# - include +# - prepend +# - extend +# ---- +# +# @example +# # bad +# # Expect extend be before constant +# class Person < ApplicationRecord +# has_many :orders +# ANSWER = 42 +# +# extend SomeModule +# include AnotherModule +# end +# +# # good +# class Person +# # extend and include go first +# extend SomeModule +# include AnotherModule +# +# # inner classes +# CustomError = Class.new(StandardError) +# +# # constants are next +# SOME_CONSTANT = 20 +# +# # afterwards we have public attribute macros +# attr_reader :name +# +# # followed by other macros (if any) +# validates :name +# +# # then we have public delegate macros +# delegate :to_s, to: :name +# +# # public class methods are next in line +# def self.some_method +# end +# +# # initialization goes between class methods and instance methods +# def initialize +# end +# +# # followed by other public instance methods +# def some_method +# end +# +# # protected attribute macros and methods go next +# protected +# +# attr_reader :protected_name +# +# def some_protected_method +# end +# +# # private attribute macros, delegate macros and methods +# # are grouped near the end +# private +# +# attr_reader :private_name +# +# delegate :some_private_delegate, to: :name +# +# def some_private_method +# end +# end +# @see https://rubystyle.guide#consistent-classes +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:136 +class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:150 + def dynamic_constant?(param0 = T.unsafe(nil)); end + + # Validates code style on class declaration. + # Add offense when find a node out of expected order. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:156 + def on_class(class_node); end + + private + + # Autocorrect by swapping between two nodes autocorrecting them + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:171 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:288 + def begin_pos_with_comment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:311 + def buffer; end + + # Setting categories hash allow you to group methods in group to match + # in the {expected_order}. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:323 + def categories; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:231 + def class_elements(class_node); end + + # Classifies a node to match with something in the {expected_order} + # + # @param node to be analysed + # @return String when the node type is a `:block` then + # {classify} recursively with the first children + # @return String when the node type is a `:send` then {find_category} + # by method name + # @return String otherwise trying to {humanize_node} of the current node + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:191 + def classify(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:280 + def end_position_for(node); end + + # Load expected order from `ExpectedOrder` config. + # Define new terms in the expected order by adding new {categories}. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:317 + def expected_order; end + + # Categorize a node according to the {expected_order} + # Try to match {categories} values against the node's method_name given + # also its visibility. + # + # @param node to be analysed. + # @return [String] with the key category or the `method_name` as string + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:209 + def find_category(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:307 + def find_heredoc(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:256 + def humanize_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:243 + def ignore?(classification); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:249 + def ignore_for_autocorrect?(node, sibling); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:265 + def source_range_with_comment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:303 + def start_line_position(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:222 + def walk_over_nested_class_definition(class_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:299 + def whole_line_comment_at_line?(line); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:140 +RuboCop::Cop::Layout::ClassStructure::HUMANIZED_NODE_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/class_structure.rb:147 +RuboCop::Cop::Layout::ClassStructure::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of here document closings. +# +# @example +# +# # bad +# class Foo +# def bar +# <<~SQL +# 'Hi' +# SQL +# end +# end +# +# # good +# class Foo +# def bar +# <<~SQL +# 'Hi' +# SQL +# end +# end +# +# # bad +# +# # heredoc contents is before closing heredoc. +# foo arg, +# <<~EOS +# Hi +# EOS +# +# # good +# foo arg, +# <<~EOS +# Hi +# EOS +# +# # good +# foo arg, +# <<~EOS +# Hi +# EOS +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:49 +class RuboCop::Cop::Layout::ClosingHeredocIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:58 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:75 + def argument_indentation_correct?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:83 + def closing_indentation(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:102 + def find_node_used_heredoc_argument(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:91 + def heredoc_closing(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:87 + def heredoc_opening(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:118 + def indent_level(source_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:95 + def indented_end(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:110 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:71 + def opening_indentation(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:54 +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:55 +RuboCop::Cop::Layout::ClosingHeredocIndentation::MSG_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb:53 +RuboCop::Cop::Layout::ClosingHeredocIndentation::SIMPLE_HEREDOC = T.let(T.unsafe(nil), String) + +# Checks the indentation of hanging closing parentheses in +# method calls, method definitions, and grouped expressions. A hanging +# closing parenthesis means `)` preceded by a line break. +# +# @example +# +# # bad +# some_method( +# a, +# b +# ) +# +# some_method( +# a, b +# ) +# +# some_method(a, b, c +# ) +# +# some_method(a, +# b, +# c +# ) +# +# some_method(a, +# x: 1, +# y: 2 +# ) +# +# # Scenario 1: When First Parameter Is On Its Own Line +# +# # good: when first param is on a new line, right paren is *always* +# # outdented by IndentationWidth +# some_method( +# a, +# b +# ) +# +# # good +# some_method( +# a, b +# ) +# +# # Scenario 2: When First Parameter Is On The Same Line +# +# # good: when all other params are also on the same line, outdent +# # right paren by IndentationWidth +# some_method(a, b, c +# ) +# +# # good: when all other params are on multiple lines, but are lined +# # up, align right paren with left paren +# some_method(a, +# b, +# c +# ) +# +# # good: when other params are not lined up on multiple lines, outdent +# # right paren by IndentationWidth +# some_method(a, +# x: 1, +# y: 2 +# ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:71 +class RuboCop::Cop::Layout::ClosingParenthesisIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:84 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:79 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:88 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:88 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:79 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:157 + def all_elements_aligned?(elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:95 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:99 + def check(node, elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:107 + def check_for_elements(node, elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:125 + def check_for_no_elements(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:171 + def correct_column_candidates(node, left_paren); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:144 + def expected_column(left_paren, elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:167 + def first_argument_line(elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:187 + def indentation_width; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:191 + def line_break_after_left_paren?(left_paren, elements); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:179 + def message(correct_column, left_paren, right_paren); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:77 +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb:75 +RuboCop::Cop::Layout::ClosingParenthesisIndentation::MSG_INDENT = T.let(T.unsafe(nil), String) + +# Checks the indentation of comments. +# +# @example +# # bad +# # comment here +# def method_name +# end +# +# # comment here +# a = 'hello' +# +# # yet another comment +# if true +# true +# end +# +# # good +# # comment here +# def method_name +# end +# +# # comment here +# a = 'hello' +# +# # yet another comment +# if true +# true +# end +# @example AllowForAlignment: false (default) +# # bad +# a = 1 # A really long comment +# # spanning two lines. +# +# # good +# # A really long comment spanning one line. +# a = 1 +# @example AllowForAlignment: true +# # good +# a = 1 # A really long comment +# # spanning two lines. +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:48 +class RuboCop::Cop::Layout::CommentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:55 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:61 + def autocorrect(corrector, comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:88 + def autocorrect_one(corrector, comment); end + + # Corrects all comment lines that occur immediately before the given + # comment and have the same indentation. This is to avoid a long chain + # of correcting, saving the file, parsing and inspecting again, and + # then correcting one more line, and so on. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:71 + def autocorrect_preceding_comments(corrector, comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:92 + def check(comment, comment_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:145 + def correct_indentation(next_line); end + + # Returns true if: + # a) the cop is configured to allow extra indentation for alignment, and + # b) the currently inspected comment is aligned with the nearest preceding end-of-line + # comment. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:121 + def correctly_aligned_with_preceding_comment?(comment_index, column); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:156 + def less_indented?(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:140 + def line_after_comment(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:131 + def message(column, correct_comment_indentation); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:135 + def own_line_comment?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:82 + def should_correct?(preceding_comment, reference_comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:160 + def two_alternatives?(line); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/comment_indentation.rb:52 +RuboCop::Cop::Layout::CommentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for conditions that are not on the same line as +# if/while/until. +# +# @example +# +# # bad +# +# if +# some_condition +# do_something +# end +# @example +# +# # good +# +# if some_condition +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:25 +class RuboCop::Cop::Layout::ConditionPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:31 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:37 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:37 + def on_while(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:44 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:58 + def message(condition); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/condition_position.rb:29 +RuboCop::Cop::Layout::ConditionPosition::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords of method definitions are +# aligned properly. +# +# Two modes are supported through the EnforcedStyleAlignWith configuration +# parameter. If it's set to `start_of_line` (which is the default), the +# `end` shall be aligned with the start of the line where the `def` +# keyword is. If it's set to `def`, the `end` shall be aligned with the +# `def` keyword. +# +# @example EnforcedStyleAlignWith: start_of_line (default) +# # bad +# +# private def foo +# end +# +# # good +# +# private def foo +# end +# @example EnforcedStyleAlignWith: def +# # bad +# +# private def foo +# end +# +# # good +# +# private def foo +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:36 +class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:43 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:43 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:48 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:63 + def autocorrect(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/def_end_alignment.rb:41 +RuboCop::Cop::Layout::DefEndAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks the . position in multi-line method calls. +# +# @example EnforcedStyle: leading (default) +# # bad +# something. +# method +# +# # good +# something +# .method +# @example EnforcedStyle: trailing +# # bad +# something +# .method +# +# # good +# something. +# method +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:25 +class RuboCop::Cop::Layout::DotPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:34 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:34 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:137 + def ampersand_dot?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:49 + def autocorrect(corrector, dot, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:99 + def correct_dot_position_style?(dot_line, selector_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:126 + def end_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:122 + def heredoc?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:114 + def last_heredoc_line(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:95 + def line_between?(first_line, second_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:64 + def message(dot); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:74 + def proper_dot_position?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:106 + def receiver_end_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:130 + def selector_range(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/dot_position.rb:30 + def autocorrect_incompatible_with; end + end +end + +# Checks the alignment of else keywords. Normally they should +# be aligned with an if/unless/while/until/begin/def/rescue keyword, but there +# are special cases when they should follow the same rules as the +# alignment of end. +# +# @example +# # bad +# if something +# code +# else +# code +# end +# +# # bad +# if something +# code +# elsif something +# code +# end +# +# # good +# if something +# code +# else +# code +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:32 +class RuboCop::Cop::Layout::ElseAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:57 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:63 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:40 + def on_if(node, base = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:51 + def on_rescue(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:147 + def assignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:71 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:106 + def base_for_method_definition(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:80 + def base_range_of_if(node, base); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:89 + def base_range_of_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:131 + def check_alignment(base_range, else_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:115 + def check_assignment(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:75 + def check_nested(node, base); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/else_alignment.rb:38 +RuboCop::Cop::Layout::ElseAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks empty comment. +# +# @example +# # bad +# +# # +# class Foo +# end +# +# # good +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# @example AllowBorderComment: true (default) +# # good +# +# def foo +# end +# +# ################# +# +# def bar +# end +# @example AllowBorderComment: false +# # bad +# +# def foo +# end +# +# ################# +# +# def bar +# end +# @example AllowMarginComment: true (default) +# # good +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# @example AllowMarginComment: false +# # bad +# +# # +# # Description of `Foo` class. +# # +# class Foo +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:63 +class RuboCop::Cop::Layout::EmptyComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:69 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:131 + def allow_border_comment?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:135 + def allow_margin_comment?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:97 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:127 + def comment_text(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:108 + def concat_consecutive_comments(comments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:139 + def current_token(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:117 + def empty_comment_only?(comment_text); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:85 + def investigate(comments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:143 + def previous_token(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_comment.rb:67 +RuboCop::Cop::Layout::EmptyComment::MSG = T.let(T.unsafe(nil), String) + +# Enforces empty line after guard clause +# +# @example +# +# # bad +# def foo +# return if need_return? +# bar +# end +# +# # good +# def foo +# return if need_return? +# +# bar +# end +# +# # good +# def foo +# return if something? +# return if something_different? +# +# bar +# end +# +# # also good +# def foo +# if something? +# do_something +# return if need_return? +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:38 +class RuboCop::Cop::Layout::EmptyLineAfterGuardClause < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:46 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:65 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:87 + def contains_guard_clause?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:80 + def correct_style?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:160 + def heredoc?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:153 + def heredoc_line(node, heredoc_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:129 + def last_heredoc_argument(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:143 + def last_heredoc_argument_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:172 + def multiple_statements_on_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:98 + def next_line_empty?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:91 + def next_line_empty_or_enable_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:102 + def next_line_enable_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:108 + def next_line_rescue_or_ensure?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:122 + def next_sibling_empty_or_guard_clause?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:113 + def next_sibling_parent_empty_or_else?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:164 + def offense_location(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:44 +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::END_OF_HEREDOC_LINE = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb:43 +RuboCop::Cop::Layout::EmptyLineAfterGuardClause::MSG = T.let(T.unsafe(nil), String) + +# Checks for a newline after the final magic comment. +# +# @example +# # good +# # frozen_string_literal: true +# +# # Some documentation for Person +# class Person +# # Some code +# end +# +# # bad +# # frozen_string_literal: true +# # Some documentation for Person +# class Person +# # Some code +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb:23 +class RuboCop::Cop::Layout::EmptyLineAfterMagicComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb:29 + def on_new_investigation; end + + private + + # Find the last magic comment in the source file. + # + # Take all comments that precede the first line of code, select the + # magic comments, and return the last magic comment in the file. + # + # @return [Parser::Source::Comment] if magic comments exist before code + # @return [nil] otherwise + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb:54 + def last_magic_comment(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb:43 + def offending_range(last_magic_comment); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_magic_comment.rb:27 +RuboCop::Cop::Layout::EmptyLineAfterMagicComment::MSG = T.let(T.unsafe(nil), String) + +# Enforces empty line after multiline condition. +# +# @example +# # bad +# if multiline && +# condition +# do_something +# end +# +# # good +# if multiline && +# condition +# +# do_something +# end +# +# # bad +# case x +# when foo, +# bar +# do_something +# end +# +# # good +# case x +# when foo, +# bar +# +# do_something +# end +# +# # bad +# begin +# do_something +# rescue FooError, +# BarError +# handle_error +# end +# +# # good +# begin +# do_something +# rescue FooError, +# BarError +# +# handle_error +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:54 +class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:82 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:60 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:93 + def on_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:70 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:75 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:70 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:75 + def on_while_post(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:127 + def autocorrect(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:105 + def check_condition(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:120 + def multiline_rescue_exceptions?(exception_nodes); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:116 + def multiline_when_condition?(when_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:112 + def next_line_empty?(line); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:58 +RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks whether class/module/method definitions are +# separated by one or more empty lines. +# +# `NumberOfEmptyLines` can be an integer (default is 1) or +# an array (e.g. [1, 2]) to specify a minimum and maximum +# number of empty lines permitted. +# +# `AllowAdjacentOneLineDefs` configures whether adjacent +# one-line definitions are considered an offense. +# +# @example AllowAdjacentOneLineDefs: false +# +# # bad +# class ErrorA < BaseError; end +# class ErrorB < BaseError; end +# class ErrorC < BaseError; end +# +# # good +# class ErrorA < BaseError; end +# +# class ErrorB < BaseError; end +# +# class ErrorC < BaseError; end +# @example +# +# # good +# def a +# end +# +# def b +# end +# @example EmptyLineBetweenClassDefs: true (default) +# # checks for empty lines between class definitions. +# +# # bad +# class A +# end +# class B +# end +# def b +# end +# @example +# +# # good +# class A +# end +# +# class B +# end +# +# def b +# end +# @example EmptyLineBetweenModuleDefs: true (default) +# # checks for empty lines between module definitions. +# +# # bad +# module A +# end +# module B +# end +# def b +# end +# @example +# +# # good +# module A +# end +# +# module B +# end +# +# def b +# end +# @example AllowAdjacentOneLineDefs: true (default) +# +# # good +# class ErrorA < BaseError; end +# class ErrorB < BaseError; end +# class ErrorC < BaseError; end +# +# # good +# class ErrorA < BaseError; end +# +# class ErrorB < BaseError; end +# +# class ErrorC < BaseError; end +# @example EmptyLineBetweenMethodDefs: true (default) +# # checks for empty lines between method definitions. +# +# # bad +# def a +# end +# def b +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:108 +class RuboCop::Cop::Layout::EmptyLineBetweenDefs < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:144 + def autocorrect(corrector, prev_def, node, count); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:130 + def check_defs(nodes); end + + # We operate on `begin` nodes, instead of using `OnMethodDef`, + # so that we can walk over pairs of consecutive nodes and + # efficiently access a node's predecessor; #prev_node ends up + # doing a linear scan over siblings, so we don't want to call + # it on each def. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:123 + def on_begin(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:267 + def allowance_range?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:251 + def autocorrect_insert_lines(corrector, newline_pos, count); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:244 + def autocorrect_remove_lines(corrector, newline_pos, count); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:208 + def blank_lines_count_between(first_def_node, second_def_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:162 + def candidate?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:172 + def class_candidate?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:232 + def def_end(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:228 + def def_start(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:236 + def end_loc(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:186 + def expected_lines; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:204 + def line_count_allowed?(count); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:220 + def lines_between_defs(first_def_node, second_def_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:216 + def maximum_empty_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:180 + def message(node, count: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:168 + def method_candidate?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:212 + def minimum_empty_lines; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:176 + def module_candidate?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:195 + def multiple_blank_lines_groups?(first_def_node, second_def_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:258 + def node_type(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:114 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_line_between_defs.rb:112 +RuboCop::Cop::Layout::EmptyLineBetweenDefs::MSG = T.let(T.unsafe(nil), String) + +# Checks for two or more consecutive blank lines. +# +# @example +# +# # bad - It has two empty lines. +# some_method +# # one empty line +# # two empty lines +# some_method +# +# # good +# some_method +# # one empty line +# some_method +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:21 +class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:28 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:43 + def each_extra_empty_line(lines); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:61 + def exceeds_line_offset?(line_diff); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:65 + def previous_and_current_lines_empty?(line); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:26 +RuboCop::Cop::Layout::EmptyLines::LINE_OFFSET = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines.rb:25 +RuboCop::Cop::Layout::EmptyLines::MSG = T.let(T.unsafe(nil), String) + +# Access modifiers should be surrounded by blank lines. +# +# @example EnforcedStyle: around (default) +# +# # bad +# class Foo +# def bar; end +# private +# def baz; end +# end +# +# # good +# class Foo +# def bar; end +# +# private +# +# def baz; end +# end +# @example EnforcedStyle: only_before +# +# # bad +# class Foo +# def bar; end +# private +# def baz; end +# end +# +# # good +# class Foo +# def bar; end +# +# private +# def baz; end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:43 +class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [EmptyLinesAroundAccessModifier] a new instance of EmptyLinesAroundAccessModifier + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:54 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:79 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:60 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:69 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:79 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:74 + def on_sclass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:85 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:113 + def allowed_only_before_style?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:162 + def block_start?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:168 + def body_end?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:156 + def class_def?(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:122 + def correct_next_line_if_denied_style(corrector, node, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:152 + def empty_lines_around?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:102 + def expected_empty_lines?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:178 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:187 + def message_for_around_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:197 + def message_for_only_before_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:174 + def next_empty_line_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:146 + def next_line_empty?(last_send_line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:139 + def previous_line_empty?(send_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:135 + def previous_line_ignoring_comments(processed_source, send_line); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:48 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:52 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_AFTER_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:49 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_AND_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_access_modifier.rb:51 +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::MSG_BEFORE_FOR_ONLY_BEFORE = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the arguments +# of a method invocation. +# +# @example +# # bad +# do_something( +# foo +# +# ) +# +# process(bar, +# +# baz: qux, +# thud: fred) +# +# some_method( +# +# [1,2,3], +# x: y +# ) +# +# # good +# do_something( +# foo +# ) +# +# process(bar, +# baz: qux, +# thud: fred) +# +# some_method( +# [1,2,3], +# x: y +# ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:41 +class RuboCop::Cop::Layout::EmptyLinesAroundArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:47 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:47 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:65 + def empty_lines(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:71 + def extra_lines(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:93 + def inner_lines(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:84 + def line_numbers(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:97 + def outer_lines(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:78 + def processed_lines(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:61 + def receiver_and_method_call_on_different_lines?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_arguments.rb:45 +RuboCop::Cop::Layout::EmptyLinesAroundArguments::MSG = T.let(T.unsafe(nil), String) + +# Checks for a newline after an attribute accessor or a group of them. +# `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed +# by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options. +# +# @example +# # bad +# attr_accessor :foo +# def do_something +# end +# +# # good +# attr_accessor :foo +# +# def do_something +# end +# +# # good +# attr_accessor :foo +# attr_reader :bar +# attr_writer :baz +# attr :qux +# +# def do_something +# end +# @example AllowAliasSyntax: true (default) +# # good +# attr_accessor :foo +# alias :foo? :foo +# +# def do_something +# end +# @example AllowAliasSyntax: false +# # bad +# attr_accessor :foo +# alias :foo? :foo +# +# def do_something +# end +# +# # good +# attr_accessor :foo +# +# alias :foo? :foo +# +# def do_something +# end +# @example AllowedMethods: ['private'] +# # good +# attr_accessor :foo +# private :foo +# +# def do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:63 +class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:70 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:123 + def allow_alias?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:133 + def allow_alias_syntax?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:127 + def attribute_or_allowed_method?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:83 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:107 + def next_line_empty?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:94 + def next_line_empty_or_enable_directive_comment?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:101 + def next_line_enable_directive_comment?(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:117 + def next_line_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:111 + def require_empty_line?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:68 +RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::MSG = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of begin-end +# blocks. +# +# @example +# +# # good +# +# begin +# # ... +# end +# +# # bad +# +# begin +# +# # ... +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_begin_body.rb:24 +class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_begin_body.rb:30 + def on_kwbegin(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_begin_body.rb:36 + def style; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_begin_body.rb:28 +RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of blocks match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# foo do |bar| +# # ... +# end +# @example EnforcedStyle: empty_lines +# # good +# +# foo do |bar| +# +# # ... +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_block_body.rb:24 +class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_block_body.rb:30 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_block_body.rb:30 + def on_numblock(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_block_body.rb:28 +RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::KIND = T.let(T.unsafe(nil), String) + +# Common functionality for checking if presence/absence of empty lines +# around some kind of body matches the configuration. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:8 +module RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:20 + def constant_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:23 + def empty_line_required?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:26 + def check(node, body, adjusted_first_line: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:81 + def check_beginning(style, first_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:67 + def check_both(style, first_line, last_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:108 + def check_deferred_empty_line(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:43 + def check_empty_lines_except_namespace(body, first_line, last_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:51 + def check_empty_lines_special(body, first_line, last_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:85 + def check_ending(style, last_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:98 + def check_line(style, line, msg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:89 + def check_source(style, line_no, desc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:159 + def deferred_message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:132 + def first_child_requires_empty_line?(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:140 + def first_empty_line_required_child(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:155 + def message(type, desc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:122 + def namespace?(body, with_one_child: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:148 + def previous_line_ignoring_comments(send_line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:163 + def valid_body_style?(body); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:15 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:13 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_EXTRA = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/empty_lines_around_body.rb:14 +RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_MISSING = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of classes match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# class Foo +# def bar +# # ... +# end +# end +# @example EnforcedStyle: empty_lines +# # good +# +# class Foo +# +# def bar +# # ... +# end +# +# end +# @example EnforcedStyle: empty_lines_except_namespace +# # good +# +# class Foo +# class Bar +# +# # ... +# +# end +# end +# @example EnforcedStyle: empty_lines_special +# # good +# class Foo +# +# def bar; end +# +# end +# @example EnforcedStyle: beginning_only +# # good +# +# class Foo +# +# def bar +# # ... +# end +# end +# @example EnforcedStyle: ending_only +# # good +# +# class Foo +# def bar +# # ... +# end +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_class_body.rb:67 +class RuboCop::Cop::Layout::EmptyLinesAroundClassBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_class_body.rb:73 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_class_body.rb:79 + def on_sclass(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_class_body.rb:71 +RuboCop::Cop::Layout::EmptyLinesAroundClassBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of `begin` +# sections. This cop doesn't check empty lines at `begin` body +# beginning/end and around method definition body. +# `Style/EmptyLinesAroundBeginBody` or `Style/EmptyLinesAroundMethodBody` +# can be used for this purpose. +# +# @example +# +# # good +# +# begin +# do_something +# rescue +# do_something2 +# else +# do_something3 +# ensure +# do_something4 +# end +# +# # good +# +# def foo +# do_something +# rescue +# do_something2 +# end +# +# # bad +# +# begin +# do_something +# +# rescue +# +# do_something2 +# +# else +# +# do_something3 +# +# ensure +# +# do_something4 +# end +# +# # bad +# +# def foo +# do_something +# +# rescue +# +# do_something2 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:61 +class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:67 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:67 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:72 + def on_kwbegin(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:79 + def check_body(body, line_of_def_or_kwbegin); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:106 + def keyword_locations(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:123 + def keyword_locations_in_ensure(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:119 + def keyword_locations_in_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:94 + def last_rescue_and_end_on_same_line(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:98 + def message(location, keyword); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:102 + def style; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:65 +RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG = T.let(T.unsafe(nil), String) + +# Checks if empty lines exist around the bodies of methods. +# +# @example +# +# # good +# +# def foo +# # ... +# end +# +# # bad +# +# def bar +# +# # ... +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_method_body.rb:23 +class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_method_body.rb:29 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_method_body.rb:29 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_method_body.rb:36 + def style; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_method_body.rb:27 +RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::KIND = T.let(T.unsafe(nil), String) + +# Checks if empty lines around the bodies of modules match +# the configuration. +# +# @example EnforcedStyle: no_empty_lines (default) +# # good +# +# module Foo +# def bar +# # ... +# end +# end +# @example EnforcedStyle: empty_lines +# # good +# +# module Foo +# +# def bar +# # ... +# end +# +# end +# @example EnforcedStyle: empty_lines_except_namespace +# # good +# +# module Foo +# module Bar +# +# # ... +# +# end +# end +# @example EnforcedStyle: empty_lines_special +# # good +# module Foo +# +# def bar; end +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_module_body.rb:47 +class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_module_body.rb:53 + def on_module(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/empty_lines_around_module_body.rb:51 +RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::KIND = T.let(T.unsafe(nil), String) + +# Checks whether the end keywords are aligned properly. +# +# Three modes are supported through the `EnforcedStyleAlignWith` +# configuration parameter: +# +# If it's set to `keyword` (which is the default), the `end` +# shall be aligned with the start of the keyword (if, class, etc.). +# +# If it's set to `variable` the `end` shall be aligned with the +# left-hand-side of the variable assignment, if there is one. +# +# If it's set to `start_of_line`, the `end` shall be aligned with the +# start of the line where the matching keyword appears. +# +# This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`) +# by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with +# `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends +# to align with the start of the line. These style can be configured by each cop. +# +# @example EnforcedStyleAlignWith: keyword (default) +# # bad +# +# variable = if true +# end +# +# # good +# +# variable = if true +# end +# +# variable = +# if true +# end +# @example EnforcedStyleAlignWith: variable +# # bad +# +# variable = if true +# end +# +# # good +# +# variable = if true +# end +# +# variable = +# if true +# end +# @example EnforcedStyleAlignWith: start_of_line +# # bad +# +# variable = if true +# end +# +# puts(if true +# end) +# +# # good +# +# variable = if true +# end +# +# puts(if true +# end) +# +# variable = +# if true +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:75 +class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:101 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:81 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:89 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:85 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:97 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:93 + def on_while(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:156 + def alignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:167 + def alignment_node_for_variable_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:137 + def asgn_variable_align_with(outer_node, inner_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:182 + def assignment_or_operator_method(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:111 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:126 + def check_asgn_alignment(outer_node, inner_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:115 + def check_assignment(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_alignment.rb:147 + def check_other_alignment(node); end +end + +# Checks for Windows-style line endings in the source code. +# +# @example EnforcedStyle: native (default) +# # The `native` style means that CR+LF (Carriage Return + Line Feed) is +# # enforced on Windows, and LF is enforced on other platforms. +# +# # bad +# puts 'Hello' # Return character is LF on Windows. +# puts 'Hello' # Return character is CR+LF on other than Windows. +# +# # good +# puts 'Hello' # Return character is CR+LF on Windows. +# puts 'Hello' # Return character is LF on other than Windows. +# @example EnforcedStyle: lf +# # The `lf` style means that LF (Line Feed) is enforced on +# # all platforms. +# +# # bad +# puts 'Hello' # Return character is CR+LF on all platforms. +# +# # good +# puts 'Hello' # Return character is LF on all platforms. +# @example EnforcedStyle: crlf +# # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is +# # enforced on all platforms. +# +# # bad +# puts 'Hello' # Return character is LF on all platforms. +# +# # good +# puts 'Hello' # Return character is CR+LF on all platforms. +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:40 +class RuboCop::Cop::Layout::EndOfLine < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:71 + def offense_message(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:47 + def on_new_investigation; end + + # If there is no LF on the last line, we don't care if there's no CR. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:67 + def unimportant_missing_cr?(index, last_line, line); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:85 + def last_line(processed_source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:44 +RuboCop::Cop::Layout::EndOfLine::MSG_DETECTED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/end_of_line.rb:45 +RuboCop::Cop::Layout::EndOfLine::MSG_MISSING = T.let(T.unsafe(nil), String) + +# Checks for extra/unnecessary whitespace. +# +# @example +# +# # good if AllowForAlignment is true +# name = "RuboCop" +# # Some comment and an empty line +# +# website += "/rubocop/rubocop" unless cond +# puts "rubocop" if debug +# +# # bad for any configuration +# set_app("RuboCop") +# website = "https://github.com/rubocop/rubocop" +# +# # good only if AllowBeforeTrailingComments is true +# object.method(arg) # this is a comment +# +# # good even if AllowBeforeTrailingComments is false or not set +# object.method(arg) # this is a comment +# +# # good with either AllowBeforeTrailingComments or AllowForAlignment +# object.method(arg) # this is a comment +# another_object.method(arg) # this is another comment +# some_object.method(arg) # this is some comment +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:31 +class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:39 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:167 + def align_column(asgn_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:144 + def align_equal_sign(corrector, token, align_to); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:134 + def align_equal_signs(range, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:52 + def aligned_locations(locs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:104 + def aligned_tok?(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:156 + def all_relevant_assignment_lines(line_number); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:176 + def allow_for_trailing_comments?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:73 + def check_assignment(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:82 + def check_other(token1, token2, ast); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:63 + def check_tokens(ast, token1, token2); end + + # @yield [range_between(start_pos, end_pos)] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:92 + def extra_space_range(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:130 + def force_equal_sign_alignment?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:112 + def ignored_range?(ast, start_pos); end + + # Returns an array of ranges that should not be reported. It's the + # extra spaces between the keys and values in a multiline hash, + # since those are handled by the Layout/HashAlignment cop. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:119 + def ignored_ranges(ast); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:37 +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/extra_spacing.rb:36 +RuboCop::Cop::Layout::ExtraSpacing::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first argument in a method call. +# Arguments after the first one are checked by `Layout/ArgumentAlignment`, +# not by this cop. +# +# For indenting the first parameter of method _definitions_, check out +# `Layout/FirstParameterIndentation`. +# +# This cop will respect `Layout/ArgumentAlignment` and will not work when +# `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`. +# +# @example +# +# # bad +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default) +# # Same as `special_for_inner_method_call` except that the special rule +# # only applies if the outer method call encloses its arguments in +# # parentheses. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: consistent +# # The first argument should always be indented one step more than the +# # preceding line. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# @example EnforcedStyle: consistent_relative_to_receiver +# # The first argument should always be indented one level relative to +# # the parent that is receiving the argument +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_params +# @example EnforcedStyle: special_for_inner_method_call +# # The first argument should normally be indented one step more than +# # the preceding line, but if it's a argument for a method call that +# # is itself a argument in a method call, then the inner argument +# # should be indented relative to the inner method. +# +# # good +# some_method( +# first_param, +# second_param) +# +# foo = some_method( +# first_param, +# second_param) +# +# foo = some_method(nested_call( +# nested_first_param), +# second_param) +# +# foo = some_method( +# nested_call( +# nested_first_param), +# second_param) +# +# some_method nested_call( +# nested_first_param), +# second_param +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:147 +class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:216 + def eligible_method_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:155 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:155 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:275 + def argument_alignment_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:168 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:172 + def bare_operator?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:192 + def base_indentation(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:220 + def base_range(send_node, arg_node); end + + # Returns the column of the given range. For single line ranges, this + # is simple. For ranges with line breaks, we look a the last code line. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:232 + def column_of(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:253 + def comment_lines; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:271 + def enable_layout_first_method_argument_line_break?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:265 + def enforce_first_argument_with_fixed_indentation?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:176 + def message(arg_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:261 + def on_new_investigation; end + + # Takes the line number of a given code line and returns a string + # containing the previous line that's not a comment line or a blank + # line. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:244 + def previous_code_line(line_number); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:200 + def special_inner_call_indentation?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_argument_indentation.rb:153 +RuboCop::Cop::Layout::FirstArgumentIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first element in an array literal +# where the opening bracket and the first element are on separate lines. +# The other elements' indentations are handled by the ArrayAlignment cop. +# +# By default, array literals that are arguments in a method call with +# parentheses, and where the opening square bracket of the array is on the +# same line as the opening parenthesis of the method call, shall have +# their first element indented one step (two spaces) more than the +# position inside the opening parenthesis. +# +# Other array literals shall have their first element indented one step +# more than the start of the line where the opening square bracket is. +# +# This default style is called 'special_inside_parentheses'. Alternative +# styles are 'consistent' and 'align_brackets'. Here are examples: +# +# @example EnforcedStyle: special_inside_parentheses (default) +# # The `special_inside_parentheses` style enforces that the first +# # element in an array literal where the opening bracket and first +# # element are on separate lines is indented one step (two spaces) more +# # than the position inside the opening parenthesis. +# +# #bad +# array = [ +# :value +# ] +# and_in_a_method_call([ +# :no_difference +# ]) +# +# #good +# array = [ +# :value +# ] +# but_in_a_method_call([ +# :its_like_this +# ]) +# @example EnforcedStyle: consistent +# # The `consistent` style enforces that the first element in an array +# # literal where the opening bracket and the first element are on +# # separate lines is indented the same as an array literal which is not +# # defined inside a method call. +# +# #bad +# # consistent +# array = [ +# :value +# ] +# but_in_a_method_call([ +# :its_like_this +# ]) +# +# #good +# array = [ +# :value +# ] +# and_in_a_method_call([ +# :no_difference +# ]) +# @example EnforcedStyle: align_brackets +# # The `align_brackets` style enforces that the opening and closing +# # brackets are indented to the same position. +# +# #bad +# # align_brackets +# and_now_for_something = [ +# :completely_different +# ] +# +# #good +# # align_brackets +# and_now_for_something = [ +# :completely_different +# ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:82 +class RuboCop::Cop::Layout::FirstArrayElementIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:91 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:95 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:95 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:104 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:142 + def base_description(indent_base_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:108 + def brace_alignment_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:112 + def check(array_node, left_parenthesis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:126 + def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:155 + def message(base_description); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:163 + def message_for_right_bracket(indent_base_type); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_indentation.rb:88 +RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first element in a +# multi-line array. +# +# @example +# +# # bad +# [ :a, +# :b] +# +# # good +# [ +# :a, +# :b] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_line_break.rb:20 +class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_line_break.rb:26 + def on_array(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_line_break.rb:34 + def assignment_on_same_line?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_array_element_line_break.rb:24 +RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first key in a hash literal +# where the opening brace and the first key are on separate lines. The +# other keys' indentations are handled by the HashAlignment cop. +# +# By default, Hash literals that are arguments in a method call with +# parentheses, and where the opening curly brace of the hash is on the +# same line as the opening parenthesis of the method call, shall have +# their first key indented one step (two spaces) more than the position +# inside the opening parenthesis. +# +# Other hash literals shall have their first key indented one step more +# than the start of the line where the opening curly brace is. +# +# This default style is called 'special_inside_parentheses'. Alternative +# styles are 'consistent' and 'align_braces'. Here are examples: +# +# @example EnforcedStyle: special_inside_parentheses (default) +# # The `special_inside_parentheses` style enforces that the first key +# # in a hash literal where the opening brace and the first key are on +# # separate lines is indented one step (two spaces) more than the +# # position inside the opening parentheses. +# +# # bad +# hash = { +# key: :value +# } +# and_in_a_method_call({ +# no: :difference +# }) +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# # good +# special_inside_parentheses +# hash = { +# key: :value +# } +# but_in_a_method_call({ +# its_like: :this +# }) +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# @example EnforcedStyle: consistent +# # The `consistent` style enforces that the first key in a hash +# # literal where the opening brace and the first key are on +# # separate lines is indented the same as a hash literal which is not +# # defined inside a method call. +# +# # bad +# hash = { +# key: :value +# } +# but_in_a_method_call({ +# its_like: :this +# }) +# +# # good +# hash = { +# key: :value +# } +# and_in_a_method_call({ +# no: :difference +# }) +# @example EnforcedStyle: align_braces +# # The `align_brackets` style enforces that the opening and closing +# # braces are indented to the same position. +# +# # bad +# and_now_for_something = { +# completely: :different +# } +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# # good +# and_now_for_something = { +# completely: :different +# } +# takes_multi_pairs_hash(x: { +# a: 1, +# b: 2 +# }, +# y: { +# c: 1, +# d: 2 +# }) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:113 +class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:126 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:122 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:126 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:233 + def argument_alignment_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:137 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:191 + def base_description(indent_base_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:141 + def brace_alignment_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:145 + def check(hash_node, left_parenthesis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:184 + def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:164 + def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:227 + def enforce_first_argument_with_fixed_indentation?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:204 + def message(base_description); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:212 + def message_for_right_brace(indent_base_type); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:178 + def separator_style?(first_pair); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_indentation.rb:119 +RuboCop::Cop::Layout::FirstHashElementIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first element in a +# multi-line hash. +# +# @example +# +# # bad +# { a: 1, +# b: 2} +# +# # good +# { +# a: 1, +# b: 2 } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_line_break.rb:19 +class RuboCop::Cop::Layout::FirstHashElementLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_line_break.rb:25 + def on_hash(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_hash_element_line_break.rb:23 +RuboCop::Cop::Layout::FirstHashElementLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first argument in a +# multi-line method call. +# +# @example +# +# # bad +# method(foo, bar, +# baz) +# +# # good +# method( +# foo, bar, +# baz) +# +# # ignored +# method foo, bar, +# baz +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_argument_line_break.rb:23 +class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_argument_line_break.rb:29 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_argument_line_break.rb:29 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_argument_line_break.rb:29 + def on_super(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_argument_line_break.rb:27 +RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks for a line break before the first parameter in a +# multi-line method parameter definition. +# +# @example +# +# # bad +# def method(foo, bar, +# baz) +# do_something +# end +# +# # good +# def method( +# foo, bar, +# baz) +# do_something +# end +# +# # ignored +# def method foo, +# bar +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_parameter_line_break.rb:29 +class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FirstElementLineBreak + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_parameter_line_break.rb:35 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_parameter_line_break.rb:35 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_method_parameter_line_break.rb:33 +RuboCop::Cop::Layout::FirstMethodParameterLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the first parameter in a method +# definition. Parameters after the first one are checked by +# Layout/ParameterAlignment, not by this cop. +# +# For indenting the first argument of method _calls_, check out +# Layout/FirstArgumentIndentation, which supports options related to +# nesting that are irrelevant for method _definitions_. +# +# @example +# +# # bad +# def some_method( +# first_param, +# second_param) +# 123 +# end +# @example EnforcedStyle: consistent (default) +# # The first parameter should always be indented one step more than the +# # preceding line. +# +# # good +# def some_method( +# first_param, +# second_param) +# 123 +# end +# @example EnforcedStyle: align_parentheses +# # The first parameter should always be indented one step more than the +# # opening parenthesis. +# +# # good +# def some_method( +# first_param, +# second_param) +# 123 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:44 +class RuboCop::Cop::Layout::FirstParameterIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:53 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:53 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:63 + def autocorrect(corrector, node); end + + # Returns the description of what the correct indentation is based on. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:83 + def base_description(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:67 + def brace_alignment_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:71 + def check(def_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:91 + def message(base_description); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/first_parameter_indentation.rb:50 +RuboCop::Cop::Layout::FirstParameterIndentation::MSG = T.let(T.unsafe(nil), String) + +# Check that the keys, separators, and values of a multi-line hash +# literal are aligned according to configuration. The configuration +# options are: +# +# * key (left align keys, one space before hash rockets and values) +# * separator (align hash rockets and colons, right align keys) +# * table (left align keys, hash rockets, and values) +# +# The treatment of hashes passed as the last argument to a method call +# can also be configured. The options are: +# +# * always_inspect +# * always_ignore +# * ignore_implicit (without curly braces) +# +# Alternatively you can specify multiple allowed styles. That's done by +# passing a list of styles to EnforcedStyles. +# +# @example EnforcedLastArgumentHashStyle: ignore_explicit +# # Ignore only explicit hashes. +# +# # bad +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# @example EnforcedHashRocketStyle: separator +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# @example EnforcedHashRocketStyle: table +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# @example EnforcedColonStyle: key (default) +# # bad +# { +# foo: bar, +# ba: baz +# } +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedColonStyle: separator +# # bad +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedColonStyle: table +# # bad +# { +# foo: bar, +# ba: baz +# } +# +# # good +# { +# foo: bar, +# ba: baz +# } +# @example EnforcedLastArgumentHashStyle: always_inspect (default) +# # Inspect both implicit and explicit hashes. +# +# # bad +# do_something(foo: 1, +# bar: 2) +# +# # bad +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something( +# foo: 1, +# bar: 2 +# ) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something({ +# foo: 1, +# bar: 2 +# }) +# @example EnforcedLastArgumentHashStyle: always_ignore +# # Ignore both implicit and explicit hashes. +# +# # good +# do_something(foo: 1, +# bar: 2) +# +# # good +# do_something({foo: 1, +# bar: 2}) +# @example EnforcedLastArgumentHashStyle: ignore_implicit +# # Ignore only implicit hashes. +# +# # bad +# do_something({foo: 1, +# bar: 2}) +# +# # good +# do_something(foo: 1, +# bar: 2) +# @example EnforcedHashRocketStyle: key (default) +# # bad +# { +# :foo => bar, +# :ba => baz +# } +# { +# :foo => bar, +# :ba => baz +# } +# +# # good +# { +# :foo => bar, +# :ba => baz +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:178 +class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashAlignmentStyles + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Returns the value of attribute column_deltas. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:218 + def column_deltas; end + + # Sets the attribute column_deltas + # + # @param value the value to set the attribute column_deltas to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:218 + def column_deltas=(_arg0); end + + # Returns the value of attribute offenses_by. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:218 + def offenses_by; end + + # Sets the attribute offenses_by + # + # @param value the value to set the attribute offenses_by to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:218 + def offenses_by=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:208 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:195 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:195 + def on_super(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:195 + def on_yield(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:265 + def add_offenses; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:371 + def adjust(corrector, delta, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:300 + def alignment_for(pair); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:314 + def alignment_for_colons; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:310 + def alignment_for_hash_rockets; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:390 + def argument_alignment_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:233 + def argument_before_hash(hash_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:222 + def autocorrect_incompatible_with_other_cops?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:283 + def check_delta(delta, node:, alignment:); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:246 + def check_pairs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:337 + def correct_key_value(corrector, delta, key, value, separator); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:333 + def correct_no_value(corrector, key_delta, key); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:318 + def correct_node(corrector, node, delta); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:242 + def double_splat?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:384 + def enforce_first_argument_with_fixed_indentation?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:380 + def good_alignment?(column_deltas); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:291 + def ignore_hash_argument?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:353 + def new_alignment(key); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:273 + def register_offenses_with_format(offenses, format); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:237 + def reset!; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:183 +RuboCop::Cop::Layout::HashAlignment::MESSAGES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/hash_alignment.rb:193 +RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES = T.let(T.unsafe(nil), Array) + +# Checks for the placement of the closing parenthesis +# in a method call that passes a HEREDOC string as an argument. +# It should be placed at the end of the line containing the +# opening HEREDOC tag. +# +# @example +# # bad +# +# foo(<<-SQL +# bar +# SQL +# ) +# +# foo(<<-SQL, 123, <<-NOSQL, +# bar +# SQL +# baz +# NOSQL +# ) +# +# foo( +# bar(<<-SQL +# baz +# SQL +# ), +# 123, +# ) +# +# # good +# +# foo(<<-SQL) +# bar +# SQL +# +# foo(<<-SQL, 123, <<-NOSQL) +# bar +# SQL +# baz +# NOSQL +# +# foo( +# bar(<<-SQL), +# baz +# SQL +# 123, +# ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:53 +class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:64 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:179 + def add_correct_closing_paren(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:265 + def add_correct_external_trailing_comma(node, corrector); end + + # Autocorrection note: + # + # Commas are a bit tricky to handle when the method call is + # embedded in another expression. Here's an example: + # + # [ + # first_array_value, + # foo(<<-SQL, 123, 456, + # SELECT * FROM db + # SQL + # ), + # third_array_value, + # ] + # + # The "internal" trailing comma is after `456`. + # The "external" trailing comma is after `)`. + # + # To autocorrect, we remove the latter, and move the former up: + # + # [ + # first_array_value, + # foo(<<-SQL, 123, 456), + # SELECT * FROM db + # SQL + # third_array_value, + # ] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:108 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:217 + def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:283 + def external_trailing_comma?(node); end + + # Returns nil if no trailing external comma. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:288 + def external_trailing_comma_offset_from_loc_end(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:138 + def extract_heredoc(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:134 + def extract_heredoc_argument(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:224 + def find_most_bottom_of_heredoc_end(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:174 + def fix_closing_parenthesis(node, corrector); end + + # External trailing comma helpers. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:260 + def fix_external_trailing_comma(node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:150 + def heredoc_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:192 + def incorrect_parenthesis_removal_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:208 + def incorrect_parenthesis_removal_end(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:238 + def internal_trailing_comma?(node); end + + # Returns nil if no trailing internal comma. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:243 + def internal_trailing_comma_offset_from_last_arg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:116 + def outermost_send_on_same_line(heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:183 + def remove_incorrect_closing_paren(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:271 + def remove_incorrect_external_trailing_comma(node, corrector); end + + # Internal trailing comma helpers. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:232 + def remove_internal_trailing_comma(node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:202 + def safe_to_remove_line_containing_closing_paren?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:127 + def send_missing_closing_parens?(parent, child, heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:154 + def single_line_send_with_heredoc_receiver?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:299 + def space?(pos); end + + # Closing parenthesis helpers. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:163 + def subsequent_closing_parentheses_in_same_line?(outermost_send); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:60 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:57 +RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the here document bodies. The bodies +# are indented one step. +# +# Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default), +# this cop does not add any offenses for long here documents to +# avoid `Layout/LineLength`'s offenses. +# +# @example +# # bad +# <<-RUBY +# something +# RUBY +# +# # good +# <<~RUBY +# something +# RUBY +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:24 +class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:32 + def on_heredoc(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:116 + def adjust_minus(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:111 + def adjust_squiggly(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:140 + def base_indent_level(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:155 + def heredoc_body(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:159 + def heredoc_end(node); end + + # Returns '~', '-' or nil + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:147 + def heredoc_indent_type(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:151 + def indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:122 + def indented_body(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:129 + def indented_end(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:87 + def line_too_long?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:99 + def longest_line(lines); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:107 + def max_line_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:65 + def message(heredoc_indent_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:53 + def register_offense(node, heredoc_indent_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:75 + def type_message(indentation_width, current_indent_type); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:103 + def unlimited_heredoc_length?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:83 + def width_message(indentation_width); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:28 +RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/heredoc_indentation.rb:30 +RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String) + +# Checks for inconsistent indentation. +# +# The difference between `indented_internal_methods` and `normal` is +# that the `indented_internal_methods` style prescribes that in +# classes and modules the `protected` and `private` modifier keywords +# shall be indented the same as public methods and that protected and +# private members shall be indented one step more than the modifiers. +# Other than that, both styles mean that entities on the same logical +# depth shall have the same indentation. +# +# @example EnforcedStyle: normal (default) +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# @example EnforcedStyle: indented_internal_methods +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # bad +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# puts 'world' +# end +# +# protected +# +# def foo +# end +# +# private +# +# def bar +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:121 +class RuboCop::Cop::Layout::IndentationConsistency < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:128 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:132 + def on_kwbegin(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:138 + def autocorrect(corrector, node); end + + # Not all nodes define `bare_access_modifier?` (for example, + # `RuboCop::AST::DefNode` does not), so we must check `send_type?` first + # to avoid a NoMethodError. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:145 + def bare_access_modifier?(node); end + + # Returns an integer representing the correct indentation, or nil to + # indicate that the correct indentation is that of the first child that + # is not an access modifier. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:152 + def base_column_for_normal_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:172 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:187 + def check_indented_internal_methods_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:180 + def check_normal_style(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_consistency.rb:126 +RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String) + +# Checks that the indentation method is consistent. +# Either tabs only or spaces only are used for indentation. +# +# @example EnforcedStyle: spaces (default) +# # bad +# # This example uses a tab to indent bar. +# def foo +# bar +# end +# +# # good +# # This example uses spaces to indent bar. +# def foo +# bar +# end +# @example EnforcedStyle: tabs +# # bad +# # This example uses spaces to indent bar. +# def foo +# bar +# end +# +# # good +# # This example uses a tab to indent bar. +# def foo +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:34 +class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:42 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:55 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:79 + def autocorrect_lambda_for_spaces(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:74 + def autocorrect_lambda_for_tabs(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:63 + def find_offense(line, lineno); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:85 + def in_string_literal?(ranges, tabs_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:104 + def message(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:89 + def string_literal_ranges(ast); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_style.rb:40 +RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) + +# Checks for indentation that doesn't use the specified number +# of spaces. +# +# See also the IndentationConsistency cop which is the companion to this +# one. +# +# @example +# # bad +# class A +# def test +# puts 'hello' +# end +# end +# +# # good +# class A +# def test +# puts 'hello' +# end +# end +# @example AllowedPatterns: ['^\s*module'] +# # bad +# module A +# class B +# def test +# puts 'hello' +# end +# end +# end +# +# # good +# module A +# class B +# def test +# puts 'hello' +# end +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:45 +class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:57 + def access_modifier?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:81 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:138 + def on_case(case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:146 + def on_case_match(case_match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:95 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:104 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:121 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:121 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:66 + def on_ensure(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:66 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:154 + def on_if(node, base = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:73 + def on_kwbegin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:95 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:81 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:66 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:61 + def on_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:95 + def on_sclass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:104 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:128 + def on_until(node, base = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:128 + def on_while(node, base = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:225 + def access_modifier_indentation_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:163 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:233 + def check_assignment(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:253 + def check_if(node, body, else_clause, base_loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:266 + def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:167 + def check_members(base, members); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:191 + def check_members_for_indented_internal_methods_style(members); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:197 + def check_members_for_normal_style(base, members); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:339 + def check_rescue?(rescue_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:375 + def configured_indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:205 + def each_member(members); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:229 + def indentation_consistency_style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:321 + def indentation_to_check?(base_loc, body_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:217 + def indented_internal_methods_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:379 + def leftmost_modifier_of(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:300 + def message(configured_indentation_width, indentation, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:358 + def offending_range(body_node, indentation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:276 + def offense(body_node, indentation, style); end + + # Returns true if the given node is within another node that has + # already been marked for autocorrection by this cop. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:311 + def other_offense_in_same_range?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:179 + def select_check_member(member); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:343 + def skip_check?(base_loc, body_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:221 + def special_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:366 + def starts_with_access_modifier?(body_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/indentation_width.rb:53 +RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String) + +# Checks for indentation of the first non-blank non-comment +# line in a file. +# +# @example +# # bad +# class A +# def foo; end +# end +# +# # good +# class A +# def foo; end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/initial_indentation.rb:20 +class RuboCop::Cop::Layout::InitialIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/initial_indentation.rb:26 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/initial_indentation.rb:36 + def first_token; end + + # @yield [range_between(space_range.begin_pos, token.begin_pos)] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/initial_indentation.rb:40 + def space_before(token); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/initial_indentation.rb:24 +RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String) + +# Checks whether comments have a leading space after the +# `#` denoting the start of the comment. The leading space is not +# required for some RDoc special syntax, like `#++`, `#--`, +# `#:nodoc`, `=begin`- and `=end` comments, "shebang" directives, +# or rackup options. +# +# @example +# +# # bad +# #Some comment +# +# # good +# # Some comment +# @example AllowDoxygenCommentStyle: false (default) +# +# # bad +# +# #** +# # Some comment +# # Another line of comment +# #* +# @example AllowDoxygenCommentStyle: true +# +# # good +# +# #** +# # Some comment +# # Another line of comment +# #* +# @example AllowGemfileRubyComment: false (default) +# +# # bad +# +# #ruby=2.7.0 +# #ruby-gemset=myproject +# @example AllowGemfileRubyComment: true +# +# # good +# +# #ruby=2.7.0 +# #ruby-gemset=myproject +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:52 +class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:58 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:95 + def allow_doxygen_comment?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:103 + def allow_gemfile_ruby_comment?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:79 + def allowed_on_first_line?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:99 + def doxygen_comment_style?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:107 + def gemfile?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:115 + def gemfile_ruby_comment?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:75 + def hash_mark(expr); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:91 + def rackup_config_file?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:87 + def rackup_options?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:111 + def ruby_comment_in_gemfile?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:83 + def shebang?(comment); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_comment_space.rb:56 +RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary leading blank lines at the beginning +# of a file. +# +# @example +# +# # bad +# # (start of file) +# +# class Foo +# end +# +# # bad +# # (start of file) +# +# # a comment +# +# # good +# # (start of file) +# class Foo +# end +# +# # good +# # (start of file) +# # a comment +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_empty_lines.rb:30 +class RuboCop::Cop::Layout::LeadingEmptyLines < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_empty_lines.rb:35 + def on_new_investigation; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/leading_empty_lines.rb:33 +RuboCop::Cop::Layout::LeadingEmptyLines::MSG = T.let(T.unsafe(nil), String) + +# Checks that strings broken over multiple lines (by a backslash) contain +# trailing spaces instead of leading spaces (default) or leading spaces +# instead of trailing spaces. +# +# @example EnforcedStyle: trailing (default) +# # bad +# 'this text contains a lot of' \ +# ' spaces' +# +# # good +# 'this text contains a lot of ' \ +# 'spaces' +# +# # bad +# 'this text is too' \ +# ' long' +# +# # good +# 'this text is too ' \ +# 'long' +# @example EnforcedStyle: leading +# # bad +# 'this text contains a lot of ' \ +# 'spaces' +# +# # good +# 'this text contains a lot of' \ +# ' spaces' +# +# # bad +# 'this text is too ' \ +# 'long' +# +# # good +# 'this text is too' \ +# ' long' +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:43 +class RuboCop::Cop::Layout::LineContinuationLeadingSpace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:46 + def on_dstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:82 + def continuation?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:106 + def enforced_style_leading?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:68 + def investigate_leading_style(first_line, end_of_first_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:75 + def investigate_trailing_style(second_line, end_of_first_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:86 + def leading_offense_range(end_of_first_line, matches); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:98 + def message(_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:64 + def raw_lines(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_leading_space.rb:92 + def trailing_offense_range(end_of_first_line, matches); end +end + +# Checks that the backslash of a line continuation is separated from +# preceding text by exactly one space (default) or zero spaces. +# +# @example EnforcedStyle: space (default) +# # bad +# 'a'\ +# 'b' \ +# 'c' +# +# # good +# 'a' \ +# 'b' \ +# 'c' +# @example EnforcedStyle: no_space +# # bad +# 'a' \ +# 'b' \ +# 'c' +# +# # good +# 'a'\ +# 'b'\ +# 'c' +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:30 +class RuboCop::Cop::Layout::LineContinuationSpacing < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:34 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:82 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:106 + def comment_ranges(comments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:66 + def find_offensive_spacing(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:116 + def ignore_range?(backtick_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:50 + def investigate(line, line_number); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:110 + def last_line(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:74 + def message(_range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:120 + def no_space_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:124 + def space_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_continuation_spacing.rb:91 + def string_literal_ranges(ast); end +end + +# Checks the indentation of the next line after a line that ends with a string +# literal and a backslash. +# +# If `EnforcedStyle: aligned` is set, the concatenated string parts shall be aligned with the +# first part. There are some exceptions, such as implicit return values, where the +# concatenated string parts shall be indented regardless of `EnforcedStyle` configuration. +# +# If `EnforcedStyle: indented` is set, it's the second line that shall be indented one step +# more than the first line. Lines 3 and forward shall be aligned with line 2. +# +# @example +# # bad +# def some_method +# 'x' \ +# 'y' \ +# 'z' +# end +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# def some_method +# 'x' \ +# 'y' \ +# 'z' +# end +# @example EnforcedStyle: aligned (default) +# # bad +# puts 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# puts 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# @example EnforcedStyle: indented +# # bad +# result = 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# # good +# result = 'x' \ +# 'y' +# +# my_hash = { +# first: 'a message' \ +# 'in two parts' +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:74 +class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:95 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:83 + def on_dstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:135 + def add_offense_and_correction(node, message); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:107 + def always_indented?(dstr_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:126 + def base_column(child); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:111 + def check_aligned(children, start_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:120 + def check_indented(children); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:101 + def strings_concatenated_with_backslash?(dstr_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:79 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_ALIGN = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:80 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::MSG_INDENT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:81 +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::PARENT_TYPES_FOR_INDENTED = T.let(T.unsafe(nil), Array) + +# Checks the length of lines in the source code. +# The maximum length is configurable. +# The tab size is configured in the `IndentationWidth` +# of the `Layout/IndentationStyle` cop. +# It also ignores a shebang line by default. +# +# This cop has some autocorrection capabilities. +# It can programmatically shorten certain long lines by +# inserting line breaks into expressions that can be safely +# split across lines. These include arrays, hashes, and +# method calls with argument lists. +# +# If autocorrection is enabled, the following Layout cops +# are recommended to further format the broken lines. +# (Many of these are enabled by default.) +# +# * ArgumentAlignment +# * ArrayAlignment +# * BlockAlignment +# * BlockDelimiters +# * BlockEndNewline +# * ClosingParenthesisIndentation +# * FirstArgumentIndentation +# * FirstArrayElementIndentation +# * FirstHashElementIndentation +# * FirstParameterIndentation +# * HashAlignment +# * IndentationWidth +# * MultilineArrayLineBreaks +# * MultilineBlockLayout +# * MultilineHashBraceLayout +# * MultilineHashKeyLineBreaks +# * MultilineMethodArgumentLineBreaks +# * MultilineMethodParameterLineBreaks +# * ParameterAlignment +# +# Together, these cops will pretty print hashes, arrays, +# method calls, etc. For example, let's say the max columns +# is 25: +# +# @example +# +# # bad +# {foo: "0000000000", bar: "0000000000", baz: "0000000000"} +# +# # good +# {foo: "0000000000", +# bar: "0000000000", baz: "0000000000"} +# +# # good (with recommended cops enabled) +# { +# foo: "0000000000", +# bar: "0000000000", +# baz: "0000000000", +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:63 +class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckLineBreakable + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::LineLengthHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:80 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:74 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:80 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:80 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:92 + def on_investigation_end; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:88 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:74 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:80 + def on_potential_breakable_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:80 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:217 + def allow_heredoc?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:221 + def allowed_heredoc; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:181 + def allowed_line?(line, line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:133 + def breakable_block_range(block_node); end + + # Returns the value of attribute breakable_range. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:100 + def breakable_range; end + + # Sets the attribute breakable_range + # + # @param value the value to set the attribute breakable_range to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:100 + def breakable_range=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:141 + def breakable_range_after_semicolon(semicolon_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:154 + def breakable_range_by_line_index; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:248 + def check_directive_line(line, line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:123 + def check_for_breakable_block(block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:102 + def check_for_breakable_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:115 + def check_for_breakable_semicolons(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:169 + def check_line(line, line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:265 + def check_uri_line(line, line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:202 + def excess_range(uri_range, line, line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:225 + def extract_heredocs(ast); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:158 + def heredocs; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:162 + def highlight_start(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:244 + def line_in_heredoc?(line_number); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:235 + def line_in_permitted_heredoc?(line_number); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:213 + def max; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:191 + def register_offense(loc, line, line_index, length: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:187 + def shebang?(line, line_index); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/line_length.rb:72 +RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String) + +# Checks that the closing brace in an array literal is either +# on the same line as the last array element or on a new line. +# +# When using the `symmetrical` (default) style: +# +# If an array's opening brace is on the same line as the first element +# of the array, then the closing brace should be on the same line as +# the last element of the array. +# +# If an array's opening brace is on the line above the first element +# of the array, then the closing brace should be on the line below +# the last element of the array. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line array literal must be on the line +# after the last element of the array. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line array literal must be on the same +# line as the last element of the array. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# [ :a, +# :b +# ] +# +# # bad +# [ +# :a, +# :b ] +# +# # good +# [ :a, +# :b ] +# +# # good +# [ +# :a, +# :b +# ] +# @example EnforcedStyle: new_line +# # bad +# [ +# :a, +# :b ] +# +# # bad +# [ :a, +# :b ] +# +# # good +# [ :a, +# :b +# ] +# +# # good +# [ +# :a, +# :b +# ] +# @example EnforcedStyle: same_line +# # bad +# [ :a, +# :b +# ] +# +# # bad +# [ +# :a, +# :b +# ] +# +# # good +# [ +# :a, +# :b ] +# +# # good +# [ :a, +# :b ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:91 +class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:109 + def on_array(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:103 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:106 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:99 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_brace_layout.rb:95 +RuboCop::Cop::Layout::MultilineArrayBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each item in a multi-line array +# starts on a separate line. +# +# @example +# +# # bad +# [ +# a, b, +# c +# ] +# +# # good +# [ +# a, +# b, +# c +# ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_line_breaks.rb:23 +class RuboCop::Cop::Layout::MultilineArrayLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_line_breaks.rb:29 + def on_array(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_array_line_breaks.rb:27 +RuboCop::Cop::Layout::MultilineArrayLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the multiline assignments have a newline +# after the assignment operator. +# +# @example EnforcedStyle: new_line (default) +# # bad +# foo = if expression +# 'bar' +# end +# +# # good +# foo = +# if expression +# 'bar' +# end +# +# # good +# foo = +# begin +# compute +# rescue => e +# nil +# end +# @example EnforcedStyle: same_line +# # good +# foo = if expression +# 'bar' +# end +# @example SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module'] (default) +# # good +# foo = +# if expression +# 'bar' +# end +# +# # good +# foo = +# [1].map do |i| +# i + 1 +# end +# @example SupportedTypes: ['block'] +# # good +# foo = if expression +# 'bar' +# end +# +# # good +# foo = +# [1].map do |i| +# 'bar' * i +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:60 +class RuboCop::Cop::Layout::MultilineAssignmentLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:72 + def check_assignment(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:81 + def check_by_enforced_style(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:90 + def check_new_line_offense(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:98 + def check_same_line_offense(node, rhs); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:111 + def supported_types; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:66 +RuboCop::Cop::Layout::MultilineAssignmentLayout::NEW_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_assignment_layout.rb:69 +RuboCop::Cop::Layout::MultilineAssignmentLayout::SAME_LINE_OFFENSE = T.let(T.unsafe(nil), String) + +# Checks whether the multiline do end blocks have a newline +# after the start of the block. Additionally, it checks whether the block +# arguments, if any, are on the same line as the start of the +# block. Putting block arguments on separate lines, because the whole +# line would otherwise be too long, is accepted. +# +# @example +# # bad +# blah do |i| foo(i) +# bar(i) +# end +# +# # bad +# blah do +# |i| foo(i) +# bar(i) +# end +# +# # good +# blah do |i| +# foo(i) +# bar(i) +# end +# +# # bad +# blah { |i| foo(i) +# bar(i) +# } +# +# # good +# blah { |i| +# foo(i) +# bar(i) +# } +# +# # good +# blah { | +# long_list, +# of_parameters, +# that_would_not, +# fit_on_one_line +# | +# foo(i) +# bar(i) +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:51 +class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:59 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:59 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:98 + def add_offense_for_expression(node, expr, msg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:75 + def args_on_beginning_line?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:105 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:120 + def autocorrect_arguments(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:130 + def autocorrect_body(corrector, node, block_body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:142 + def block_arg_string(node, args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:90 + def characters_needed_for_space_and_pipes(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:154 + def include_trailing_comma?(args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:79 + def line_break_necessary_in_args?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:83 + def needed_length_for_args(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:56 +RuboCop::Cop::Layout::MultilineBlockLayout::ARG_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:55 +RuboCop::Cop::Layout::MultilineBlockLayout::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_block_layout.rb:57 +RuboCop::Cop::Layout::MultilineBlockLayout::PIPE_SIZE = T.let(T.unsafe(nil), Integer) + +# Checks that the closing brace in a hash literal is either +# on the same line as the last hash element, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a hash's opening brace is on the same line as the first element +# of the hash, then the closing brace should be on the same line as +# the last element of the hash. +# +# If a hash's opening brace is on the line above the first element +# of the hash, then the closing brace should be on the line below +# the last element of the hash. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line hash literal must be on the line +# after the last element of the hash. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line hash literal must be on the same +# line as the last element of the hash. +# +# @example EnforcedStyle: symmetrical (default) +# +# # bad +# { a: 1, +# b: 2 +# } +# # bad +# { +# a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 } +# +# # good +# { +# a: 1, +# b: 2 +# } +# @example EnforcedStyle: new_line +# # bad +# { +# a: 1, +# b: 2 } +# +# # bad +# { a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 +# } +# +# # good +# { +# a: 1, +# b: 2 +# } +# @example EnforcedStyle: same_line +# # bad +# { a: 1, +# b: 2 +# } +# +# # bad +# { +# a: 1, +# b: 2 +# } +# +# # good +# { +# a: 1, +# b: 2 } +# +# # good +# { a: 1, +# b: 2 } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:91 +class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:109 + def on_hash(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:103 +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:106 +RuboCop::Cop::Layout::MultilineHashBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:99 +RuboCop::Cop::Layout::MultilineHashBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:95 +RuboCop::Cop::Layout::MultilineHashBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each key in a multi-line hash +# starts on a separate line. +# +# @example +# +# # bad +# { +# a: 1, b: 2, +# c: 3 +# } +# +# # good +# { +# a: 1, +# b: 2, +# c: 3 +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb:23 +class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb:29 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb:40 + def starts_with_curly_brace?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb:27 +RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Ensures that each argument in a multi-line method call +# starts on a separate line. +# +# NOTE: This cop does not move the first argument, if you want that to +# be on a separate line, see `Layout/FirstMethodArgumentLineBreak`. +# +# @example +# +# # bad +# foo(a, b, +# c +# ) +# +# # good +# foo( +# a, +# b, +# c +# ) +# +# # good +# foo(a, b, c) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb:28 +class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb:34 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb:32 +RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks that the closing brace in a method call is either +# on the same line as the last method argument, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a method call's opening brace is on the same line as the first +# argument of the call, then the closing brace should be on the same +# line as the last argument of the call. +# +# If an method call's opening brace is on the line above the first +# argument of the call, then the closing brace should be on the line +# below the last argument of the call. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line method call must be on the line +# after the last argument of the call. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line method call must be on the same +# line as the last argument of the call. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# foo(a, +# b +# ) +# +# # bad +# foo( +# a, +# b) +# +# # good +# foo(a, +# b) +# +# # good +# foo( +# a, +# b +# ) +# @example EnforcedStyle: new_line +# # bad +# foo( +# a, +# b) +# +# # bad +# foo(a, +# b) +# +# # good +# foo(a, +# b +# ) +# +# # good +# foo( +# a, +# b +# ) +# @example EnforcedStyle: same_line +# # bad +# foo(a, +# b +# ) +# +# # bad +# foo( +# a, +# b +# ) +# +# # good +# foo( +# a, +# b) +# +# # good +# foo(a, +# b) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:91 +class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:109 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:115 + def children(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:119 + def ignored_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:123 + def single_line_ignoring_receiver?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:103 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:106 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:99 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:95 +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Checks the indentation of the method name part in method calls +# that span more than one line. +# +# @example EnforcedStyle: aligned (default) +# # bad +# while myvariable +# .b +# # do something +# end +# +# # good +# while myvariable +# .b +# # do something +# end +# +# # good +# Thing.a +# .b +# .c +# @example EnforcedStyle: indented +# # good +# while myvariable +# .b +# +# # do something +# end +# @example EnforcedStyle: indented_relative_to_receiver +# # good +# while myvariable +# .a +# .b +# +# # do something +# end +# +# # good +# myvariable = Thing +# .a +# .b +# .c +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:49 +class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + extend ::RuboCop::Cop::AutoCorrector + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:55 + def validate_config; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:136 + def align_with_base_message(rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:152 + def alignment_base(node, rhs, given_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:67 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:140 + def base_source; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:101 + def extra_indentation(given_style, parent); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:222 + def first_call_has_a_dot(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:213 + def get_dot_right_above(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:113 + def message(node, lhs, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:144 + def no_base_message(lhs, rhs, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:87 + def offending_range(node, lhs, rhs, given_style); end + + # @yield [operation_rhs.first_argument] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:232 + def operation_rhs(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:242 + def operator_rhs?(node, receiver); end + + # a + # .b + # .c + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:193 + def receiver_alignment_base(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:131 + def relative_to_receiver_message(rhs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:71 + def relevant_node?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:75 + def right_hand_side(send_node); end + + # a.b + # .c + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:181 + def semantic_alignment_base(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:201 + def semantic_alignment_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:127 + def should_align_with_base?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:123 + def should_indent_relative_to_receiver?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_call_indentation.rb:163 + def syntactic_alignment_base(lhs, rhs); end +end + +# Checks that the closing brace in a method definition is either +# on the same line as the last method parameter, or a new line. +# +# When using the `symmetrical` (default) style: +# +# If a method definition's opening brace is on the same line as the +# first parameter of the definition, then the closing brace should be +# on the same line as the last parameter of the definition. +# +# If an method definition's opening brace is on the line above the first +# parameter of the definition, then the closing brace should be on the +# line below the last parameter of the definition. +# +# When using the `new_line` style: +# +# The closing brace of a multi-line method definition must be on the line +# after the last parameter of the definition. +# +# When using the `same_line` style: +# +# The closing brace of a multi-line method definition must be on the same +# line as the last parameter of the definition. +# +# @example EnforcedStyle: symmetrical (default) +# # bad +# def foo(a, +# b +# ) +# end +# +# # bad +# def foo( +# a, +# b) +# end +# +# # good +# def foo(a, +# b) +# end +# +# # good +# def foo( +# a, +# b +# ) +# end +# @example EnforcedStyle: new_line +# # bad +# def foo( +# a, +# b) +# end +# +# # bad +# def foo(a, +# b) +# end +# +# # good +# def foo(a, +# b +# ) +# end +# +# # good +# def foo( +# a, +# b +# ) +# end +# @example EnforcedStyle: same_line +# # bad +# def foo(a, +# b +# ) +# end +# +# # bad +# def foo( +# a, +# b +# ) +# end +# +# # good +# def foo( +# a, +# b) +# end +# +# # good +# def foo(a, +# b) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:103 +class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:121 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:121 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:115 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:118 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::ALWAYS_SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:111 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::NEW_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:107 +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::SAME_LINE_MESSAGE = T.let(T.unsafe(nil), String) + +# Ensures that each parameter in a multi-line method definition +# starts on a separate line. +# +# NOTE: This cop does not move the first argument, if you want that to +# be on a separate line, see `Layout/FirstMethodParameterLineBreak`. +# +# @example +# +# # bad +# def foo(a, b, +# c +# ) +# end +# +# # good +# def foo( +# a, +# b, +# c +# ) +# end +# +# # good +# def foo(a, b, c) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb:31 +class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MultilineElementLineBreaks + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb:37 + def on_def(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_method_parameter_line_breaks.rb:35 +RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::MSG = T.let(T.unsafe(nil), String) + +# Checks the indentation of the right hand side operand in binary operations that +# span more than one line. +# +# The `aligned` style checks that operators are aligned if they are part of an `if` or `while` +# condition, an explicit `return` statement, etc. In other contexts, the second operand should +# be indented regardless of enforced style. +# +# @example EnforcedStyle: aligned (default) +# # bad +# if a + +# b +# something && +# something_else +# end +# +# # good +# if a + +# b +# something && +# something_else +# end +# @example EnforcedStyle: indented +# # bad +# if a + +# b +# something && +# something_else +# end +# +# # good +# if a + +# b +# something && +# something_else +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:43 +class RuboCop::Cop::Layout::MultilineOperationIndentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:49 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:53 + def on_or(node); end + + # @raise [ValidationError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:57 + def validate_config; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:68 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:78 + def check_and_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:110 + def message(node, lhs, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:84 + def offending_range(node, lhs, rhs, given_style); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:72 + def relevant_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:121 + def right_hand_side(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/multiline_operation_indentation.rb:97 + def should_align?(node, rhs, given_style); end +end + +# Here we check if the parameters on a multi-line method call or +# definition are aligned. +# +# To set the alignment of the first argument, use the cop +# FirstParameterIndentation. +# +# @example EnforcedStyle: with_first_parameter (default) +# # good +# +# def foo(bar, +# baz) +# 123 +# end +# +# def foo( +# bar, +# baz +# ) +# 123 +# end +# +# # bad +# +# def foo(bar, +# baz) +# 123 +# end +# +# # bad +# +# def foo( +# bar, +# baz) +# 123 +# end +# @example EnforcedStyle: with_fixed_indentation +# # good +# +# def foo(bar, +# baz) +# 123 +# end +# +# def foo( +# bar, +# baz +# ) +# 123 +# end +# +# # bad +# +# def foo(bar, +# baz) +# 123 +# end +# +# # bad +# +# def foo( +# bar, +# baz) +# 123 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:71 +class RuboCop::Cop::Layout::ParameterAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:81 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:81 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:90 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:102 + def base_column(node, args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:98 + def fixed_indentation?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:94 + def message(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:113 + def target_method_lineno(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:75 +RuboCop::Cop::Layout::ParameterAlignment::ALIGN_PARAMS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/parameter_alignment.rb:78 +RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil), String) + +# Checks whether certain expressions, e.g. method calls, that could fit +# completely on a single line, are broken up into multiple lines unnecessarily. +# +# @example any configuration +# # bad +# foo( +# a, +# b +# ) +# +# puts 'string that fits on ' \ +# 'a single line' +# +# things +# .select { |thing| thing.cond? } +# .join('-') +# +# # good +# foo(a, b) +# +# puts 'string that fits on a single line' +# +# things.select { |thing| thing.cond? }.join('-') +# @example InspectBlocks: false (default) +# # good +# foo(a) do |x| +# puts x +# end +# @example InspectBlocks: true +# # bad +# foo(a) do |x| +# puts x +# end +# +# # good +# foo(a) { |x| puts x } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:45 +class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:51 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:64 + def check_assignment(node, _rhs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:113 + def comment_within?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:83 + def configured_to_not_be_inspected?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:107 + def convertible_block?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:133 + def max_line_length; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:77 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:90 + def other_cop_takes_precedence?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:70 + def register_offense(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:96 + def single_line_block_chain_enabled?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:100 + def suitable_as_single_line?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:124 + def to_single_line(source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:119 + def too_long?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/redundant_line_break.rb:49 +RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String) + +# Checks whether the rescue and ensure keywords are aligned +# properly. +# +# @example +# +# # bad +# begin +# something +# rescue +# puts 'error' +# end +# +# # good +# begin +# something +# rescue +# puts 'error' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:24 +class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::EndKeywordAlignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:40 + def on_ensure(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:44 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:36 + def on_resbody(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:186 + def access_modifier?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:163 + def access_modifier_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:149 + def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:136 + def aligned_with_line_break_method?(ancestor_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:195 + def alignment_location(alignment_node); end + + # We will use ancestor or wrapper with access modifier. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:116 + def alignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:95 + def alignment_source(node, starting_loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:132 + def ancestor_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:155 + def assignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:73 + def autocorrect(corrector, node, alignment_location); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:203 + def begin_end_alignment_style; end + + # Check alignment of node with rescue or ensure modifiers. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:57 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:83 + def format_message(alignment_node, alignment_loc, kw_loc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:173 + def modifier?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:179 + def whitespace_range(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:34 +RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:32 +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:33 +RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/rescue_ensure_alignment.rb:29 +RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String) + +# Checks if method calls are chained onto single line blocks. It considers that a +# line break before the dot improves the readability of the code. +# +# @example +# # bad +# example.select { |item| item.cond? }.join('-') +# +# # good +# example.select { |item| item.cond? } +# .join('-') +# +# # good (not a concern for this cop) +# example.select do |item| +# item.cond? +# end.join('-') +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:22 +class RuboCop::Cop::Layout::SingleLineBlockChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:28 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:51 + def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:35 + def offending_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:57 + def selector_range(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/single_line_block_chain.rb:26 +RuboCop::Cop::Layout::SingleLineBlockChain::MSG = T.let(T.unsafe(nil), String) + +# Checks for colon (:) not followed by some kind of space. +# N.B. this cop does not handle spaces after a ternary operator, which are +# instead handled by Layout/SpaceAroundOperators. +# +# @example +# # bad +# def f(a:, b:2); {a:3}; end +# +# # good +# def f(a:, b: 2); {a: 3}; end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:16 +class RuboCop::Cop::Layout::SpaceAfterColon < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:29 + def on_kwoptarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:21 + def on_pair(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:43 + def followed_by_space?(colon); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:39 + def register_offense(colon); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_colon.rb:19 +RuboCop::Cop::Layout::SpaceAfterColon::MSG = T.let(T.unsafe(nil), String) + +# Checks for comma (,) not followed by some kind of space. +# +# @example +# +# # bad +# [1,2] +# { foo:bar,} +# +# # good +# [1, 2] +# { foo:bar, } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_comma.rb:17 +class RuboCop::Cop::Layout::SpaceAfterComma < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SpaceAfterPunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_comma.rb:26 + def kind(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_comma.rb:21 + def space_style_before_rcurly; end +end + +# Checks for space between a method name and a left parenthesis in defs. +# +# @example +# +# # bad +# def func (x) end +# def method= (y) end +# +# # good +# def func(x) end +# def method=(y) end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_method_name.rb:17 +class RuboCop::Cop::Layout::SpaceAfterMethodName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_method_name.rb:23 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_method_name.rb:23 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_method_name.rb:21 +RuboCop::Cop::Layout::SpaceAfterMethodName::MSG = T.let(T.unsafe(nil), String) + +# Checks for space after `!`. +# +# @example +# # bad +# ! something +# +# # good +# !something +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_not.rb:14 +class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_not.rb:21 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_not.rb:33 + def whitespace_after_operator?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_not.rb:18 +RuboCop::Cop::Layout::SpaceAfterNot::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_not.rb:19 +RuboCop::Cop::Layout::SpaceAfterNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for semicolon (;) not followed by some kind of space. +# +# @example +# # bad +# x = 1;y = 2 +# +# # good +# x = 1; y = 2 +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_semicolon.rb:14 +class RuboCop::Cop::Layout::SpaceAfterSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SpaceAfterPunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_semicolon.rb:23 + def kind(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_after_semicolon.rb:18 + def space_style_before_rcurly; end +end + +# Checks the spacing inside and after block parameters pipes. Line breaks +# inside parameter pipes are checked by `Layout/MultilineBlockLayout` and +# not by this cop. +# +# @example EnforcedStyleInsidePipes: no_space (default) +# # bad +# {}.each { | x, y |puts x } +# ->( x, y ) { puts x } +# +# # good +# {}.each { |x, y| puts x } +# ->(x, y) { puts x } +# @example EnforcedStyleInsidePipes: space +# # bad +# {}.each { |x, y| puts x } +# ->(x, y) { puts x } +# +# # good +# {}.each { | x, y | puts x } +# ->( x, y ) { puts x } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:27 +class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:32 + def on_block(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:65 + def check_after_closing_pipe(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:125 + def check_arg(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:103 + def check_closing_pipe_space(arguments, closing_pipe); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:121 + def check_each_arg(args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:56 + def check_inside_pipes(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:150 + def check_no_space(space_begin_pos, space_end_pos, msg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:73 + def check_no_space_style_inside_pipes(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:92 + def check_opening_pipe_space(arguments, opening_pipe); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:136 + def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:85 + def check_space_style_inside_pipes(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:113 + def last_end_pos_inside_pipes(arguments, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:44 + def pipes(arguments); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:48 + def pipes?(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_block_parameters.rb:52 + def style_parameter_name; end +end + +# Checks that the equals signs in parameter default assignments +# have or don't have surrounding space depending on configuration. +# +# @example EnforcedStyle: space (default) +# # bad +# def some_method(arg1=:default, arg2=nil, arg3=[]) +# # do something... +# end +# +# # good +# def some_method(arg1 = :default, arg2 = nil, arg3 = []) +# # do something... +# end +# @example EnforcedStyle: no_space +# # bad +# def some_method(arg1 = :default, arg2 = nil, arg3 = []) +# # do something... +# end +# +# # good +# def some_method(arg1=:default, arg2=nil, arg3=[]) +# # do something... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:30 +class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:38 + def on_optarg(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:67 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:46 + def check_optarg(arg, equals, value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:58 + def incorrect_style_detected(arg, value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:83 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:79 + def no_surrounding_space?(arg, equals); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:75 + def space_on_both_sides?(arg, equals); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_equals_in_parameter_default.rb:36 +RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::MSG = T.let(T.unsafe(nil), String) + +# Checks the spacing around the keywords. +# +# @example +# +# # bad +# something 'test'do|x| +# end +# +# while(something) +# end +# +# something = 123if test +# +# # good +# something 'test' do |x| +# end +# +# while (something) +# end +# +# something = 123 if test +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:27 +class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:40 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:44 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:48 + def on_break(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:52 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:56 + def on_case_match(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:156 + def on_defined?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:60 + def on_ensure(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:64 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:68 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:72 + def on_if_guard(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:76 + def on_in_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:80 + def on_kwbegin(node); end + + # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby27`. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:85 + def on_match_pattern(node); end + + # Handle one-line pattern matching syntax (`in`) with `Parser::Ruby30`. + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:92 + def on_match_pattern_p(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:96 + def on_next(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:100 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:104 + def on_postexe(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:108 + def on_preexe(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:112 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:116 + def on_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:120 + def on_return(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:124 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:128 + def on_super(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:136 + def on_unless_guard(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:140 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:144 + def on_when(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:148 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:152 + def on_yield(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:132 + def on_zsuper(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:235 + def accept_left_parenthesis?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:239 + def accept_left_square_bracket?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:243 + def accept_namespace_operator?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:228 + def accepted_opening_delimiter?(range, char); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:162 + def check(node, locations, begin_keyword = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:177 + def check_begin(node, range, begin_keyword); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:183 + def check_end(node, range, begin_keyword); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:196 + def check_keyword(node, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:192 + def do?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:251 + def namespace_operator?(range, pos); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:255 + def preceded_by_operator?(node, _range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:247 + def safe_navigation_call?(range, pos); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:217 + def space_after_missing?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:210 + def space_before_missing?(range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:36 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_PAREN = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:37 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_LEFT_SQUARE_BRACKET = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:38 +RuboCop::Cop::Layout::SpaceAroundKeyword::ACCEPT_NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:33 +RuboCop::Cop::Layout::SpaceAroundKeyword::DO = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:31 +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_AFTER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:30 +RuboCop::Cop::Layout::SpaceAroundKeyword::MSG_BEFORE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:35 +RuboCop::Cop::Layout::SpaceAroundKeyword::NAMESPACE_OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_keyword.rb:34 +RuboCop::Cop::Layout::SpaceAroundKeyword::SAFE_NAVIGATION = T.let(T.unsafe(nil), String) + +# Checks method call operators to not have spaces around them. +# +# @example +# # bad +# foo. bar +# foo .bar +# foo . bar +# foo. bar .buzz +# foo +# . bar +# . buzz +# foo&. bar +# foo &.bar +# foo &. bar +# foo &. bar&. buzz +# RuboCop:: Cop +# RuboCop:: Cop:: Cop +# :: RuboCop::Cop +# +# # good +# foo.bar +# foo.bar.buzz +# foo +# .bar +# .buzz +# foo&.bar +# foo&.bar&.buzz +# RuboCop::Cop +# RuboCop::Cop::Cop +# ::RuboCop::Cop +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:37 +class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:53 + def on_const(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:45 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:45 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:87 + def check_space(begin_pos, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:67 + def check_space_after_dot(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:81 + def check_space_after_double_colon(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:61 + def check_space_before_dot(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:43 +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_method_call_operator.rb:41 +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::SPACES_REGEXP = T.let(T.unsafe(nil), Regexp) + +# Checks that operators have space around them, except for ** which +# should or shouldn't have surrounding space depending on configuration. +# It allows vertical alignment consisting of one or more whitespace +# around operators. +# +# This cop has `AllowForAlignment` option. When `true`, allows most +# uses of extra spacing if the intent is to align with an operator on +# the previous or next line, not counting empty lines or comment lines. +# +# @example +# # bad +# total = 3*4 +# "apple"+"juice" +# my_number = 38/4 +# +# # good +# total = 3 * 4 +# "apple" + "juice" +# my_number = 38 / 4 +# @example AllowForAlignment: true (default) +# # good +# { +# 1 => 2, +# 11 => 3 +# } +# @example AllowForAlignment: false +# # bad +# { +# 1 => 2, +# 11 => 3 +# } +# @example EnforcedStyleForExponentOperator: no_space (default) +# # bad +# a ** b +# +# # good +# a**b +# @example EnforcedStyleForExponentOperator: space +# # bad +# a**b +# +# # good +# a ** b +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:53 +class RuboCop::Cop::Layout::SpaceAroundOperators < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RationalLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:119 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_assignment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:119 + def on_binary(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:111 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:119 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:78 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:135 + def on_match_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:127 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:119 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:103 + def on_or_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:70 + def on_pair(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:85 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:66 + def on_sclass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:93 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:127 + def on_special_asgn(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:236 + def align_hash_cop_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:179 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:163 + def check_operator(type, operator, right_operand); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:189 + def enclose_operator_with_space(corrector, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:216 + def excess_leading_space?(type, operator, with_space); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:231 + def excess_trailing_space?(right_operand, with_space); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:248 + def force_equal_sign_alignment?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:240 + def hash_table_style?; end + + # @yield [msg] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:174 + def offense(type, operator, with_space, right_operand); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:202 + def offense_message(type, operator, with_space, right_operand); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:159 + def operator_with_regular_syntax?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:155 + def regular_operator?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:252 + def should_not_have_surrounding_space?(operator); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:244 + def space_around_exponent_operator?; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:62 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:60 +RuboCop::Cop::Layout::SpaceAroundOperators::EXCESSIVE_SPACE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_around_operators.rb:59 +RuboCop::Cop::Layout::SpaceAroundOperators::IRREGULAR_METHODS = T.let(T.unsafe(nil), Array) + +# Checks that block braces have or don't have a space before the opening +# brace depending on configuration. +# +# @example EnforcedStyle: space (default) +# # bad +# foo.map{ |a| +# a.bar.to_s +# } +# +# # good +# foo.map { |a| +# a.bar.to_s +# } +# @example EnforcedStyle: no_space +# # bad +# foo.map { |a| +# a.bar.to_s +# } +# +# # good +# foo.map{ |a| +# a.bar.to_s +# } +# @example EnforcedStyleForEmptyBraces: space (default) +# # bad +# 7.times{} +# +# # good +# 7.times {} +# @example EnforcedStyleForEmptyBraces: no_space +# # bad +# 7.times {} +# +# # good +# 7.times{} +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:44 +class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:56 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:56 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:124 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:144 + def block_delimiters_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:83 + def check_empty(left_brace, space_plus_brace, used_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:100 + def check_non_empty(left_brace, space_plus_brace, used_style); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:140 + def conflict_with_block_delimiters?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:148 + def empty_braces?(loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:115 + def space_detected(left_brace, space_plus_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:108 + def space_missing(left_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:131 + def style_for_empty_braces; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:52 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:50 +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::DETECTED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_block_braces.rb:49 +RuboCop::Cop::Layout::SpaceBeforeBlockBraces::MISSING_MSG = T.let(T.unsafe(nil), String) + +# Checks for space between the name of a receiver and a left +# brackets. +# +# @example +# +# # bad +# collection [index_or_key] +# +# # good +# collection[index_or_key] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:17 +class RuboCop::Cop::Layout::SpaceBeforeBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:48 + def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:35 + def offense_range(node, begin_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:54 + def offense_range_for_assignment(node, begin_pos); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:67 + def reference_variable_with_brackets?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:63 + def register_offense(range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:21 +RuboCop::Cop::Layout::SpaceBeforeBrackets::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_brackets.rb:22 +RuboCop::Cop::Layout::SpaceBeforeBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for comma (,) preceded by space. +# +# @example +# # bad +# [1 , 2 , 3] +# a(1 , 2) +# each { |a , b| } +# +# # good +# [1, 2, 3] +# a(1, 2) +# each { |a, b| } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_comma.rb:19 +class RuboCop::Cop::Layout::SpaceBeforeComma < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SpaceBeforePunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_comma.rb:23 + def kind(token); end +end + +# Checks for missing space between a token and a comment on the +# same line. +# +# @example +# # bad +# 1 + 1# this operation does ... +# +# # good +# 1 + 1 # this operation does ... +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_comment.rb:15 +class RuboCop::Cop::Layout::SpaceBeforeComment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_comment.rb:20 + def on_new_investigation; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_comment.rb:18 +RuboCop::Cop::Layout::SpaceBeforeComment::MSG = T.let(T.unsafe(nil), String) + +# Checks that exactly one space is used between a method name and the +# first argument for method calls without parentheses. +# +# Alternatively, extra spaces can be added to align the argument with +# something on a preceding or following line, if the AllowForAlignment +# config parameter is true. +# +# @example +# # bad +# something x +# something y, z +# something'hello' +# +# # good +# something x +# something y, z +# something 'hello' +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:24 +class RuboCop::Cop::Layout::SpaceBeforeFirstArg < ::RuboCop::Cop::Base + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:35 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:54 + def expect_params_after_method_name?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:64 + def no_space_between_method_name_and_first_argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:50 + def regular_method_call_with_arguments?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_first_arg.rb:29 +RuboCop::Cop::Layout::SpaceBeforeFirstArg::MSG = T.let(T.unsafe(nil), String) + +# Checks for semicolon (;) preceded by space. +# +# @example +# # bad +# x = 1 ; y = 2 +# +# # good +# x = 1; y = 2 +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_semicolon.rb:14 +class RuboCop::Cop::Layout::SpaceBeforeSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SpaceBeforePunctuation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_before_semicolon.rb:18 + def kind(token); end +end + +# Checks for spaces between `->` and opening parameter +# parenthesis (`(`) in lambda literals. +# +# @example EnforcedStyle: require_no_space (default) +# # bad +# a = -> (x, y) { x + y } +# +# # good +# a = ->(x, y) { x + y } +# @example EnforcedStyle: require_space +# # bad +# a = ->(x, y) { x + y } +# +# # good +# a = -> (x, y) { x + y } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:22 +class RuboCop::Cop::Layout::SpaceInLambdaLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:30 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:50 + def arrow_lambda_with_args?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:72 + def lambda_arguments(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:65 + def range_of_offense(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:58 + def space_after_arrow(lambda_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:54 + def space_after_arrow?(lambda_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:28 +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_NO_SPACE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb:27 +RuboCop::Cop::Layout::SpaceInLambdaLiteral::MSG_REQUIRE_SPACE = T.let(T.unsafe(nil), String) + +# Checks that brackets used for array literals have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that array literals have +# # no surrounding space. +# +# # bad +# array = [ a, b, c, d ] +# +# # good +# array = [a, b, c, d] +# @example EnforcedStyle: space +# # The `space` style enforces that array literals have +# # surrounding space. +# +# # bad +# array = [a, b, c, d] +# +# # good +# array = [ a, b, c, d ] +# @example EnforcedStyle: compact +# # The `compact` style normally requires a space inside +# # array brackets, with the exception that successive left +# # or right brackets are collapsed together in nested arrays. +# +# # bad +# array = [ a, [ b, c ] ] +# array = [ +# [ a ], +# [ b, c ] +# ] +# +# # good +# array = [ a, [ b, c ]] +# array = [[ a ], +# [ b, c ]] +# @example EnforcedStyleForEmptyBrackets: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBrackets style enforces that +# # empty array brackets do not contain spaces. +# +# # bad +# foo = [ ] +# bar = [ ] +# +# # good +# foo = [] +# bar = [] +# @example EnforcedStyleForEmptyBrackets: space +# # The `space` EnforcedStyleForEmptyBrackets style enforces that +# # empty array brackets contain exactly one space. +# +# # bad +# foo = [] +# bar = [ ] +# +# # good +# foo = [ ] +# bar = [ ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:70 +class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:78 + def on_array(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:106 + def array_brackets(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:92 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:215 + def compact(corrector, bracket, side); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:202 + def compact_corrections(corrector, node, left, right); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:194 + def compact_offense(node, token, side: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:157 + def compact_offenses(node, left, right, start_ok, end_ok); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:118 + def empty_config; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:126 + def end_has_own_line?(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:133 + def index_for(node, token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:141 + def issue_offenses(node, left, right, start_ok, end_ok); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:110 + def left_array_bracket(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:137 + def line_and_column_for(token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:179 + def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:188 + def next_to_bracket?(token, side: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:153 + def next_to_comment?(node, token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:122 + def next_to_newline?(node, token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:170 + def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:114 + def right_array_bracket(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:76 +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:75 +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary additional spaces inside array percent literals +# (i.e. %i/%w). +# +# @example +# +# # bad +# %w(foo bar baz) +# # good +# %i(foo bar baz) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:15 +class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:23 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:27 + def on_percent_literal(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:37 + def each_unnecessary_space_match(node, &blk); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:20 +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb:21 +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks that block braces have or don't have surrounding space inside +# them on configuration. For blocks taking parameters, it checks that the +# left brace has or doesn't have trailing space depending on +# configuration. +# +# @example EnforcedStyle: space (default) +# # The `space` style enforces that block braces have +# # surrounding space. +# +# # bad +# some_array.each {puts e} +# +# # good +# some_array.each { puts e } +# @example EnforcedStyle: no_space +# # The `no_space` style enforces that block braces don't +# # have surrounding space. +# +# # bad +# some_array.each { puts e } +# +# # good +# some_array.each {puts e} +# @example EnforcedStyleForEmptyBraces: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBraces style enforces that +# # block braces don't have a space in between when empty. +# +# # bad +# some_array.each { } +# some_array.each { } +# some_array.each { } +# +# # good +# some_array.each {} +# @example EnforcedStyleForEmptyBraces: space +# # The `space` EnforcedStyleForEmptyBraces style enforces that +# # block braces have at least a space in between when empty. +# +# # bad +# some_array.each {} +# +# # good +# some_array.each { } +# some_array.each { } +# some_array.each { } +# @example SpaceBeforeBlockParameters: true (default) +# # The SpaceBeforeBlockParameters style set to `true` enforces that +# # there is a space between `{` and `|`. Overrides `EnforcedStyle` +# # if there is a conflict. +# +# # bad +# [1, 2, 3].each {|n| n * 2 } +# +# # good +# [1, 2, 3].each { |n| n * 2 } +# @example SpaceBeforeBlockParameters: false +# # The SpaceBeforeBlockParameters style set to `false` enforces that +# # there is no space between `{` and `|`. Overrides `EnforcedStyle` +# # if there is a conflict. +# +# # bad +# [1, 2, 3].each { |n| n * 2 } +# +# # good +# [1, 2, 3].each {|n| n * 2 } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:79 +class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:85 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:85 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:122 + def adjacent_braces(left_brace, right_brace); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:160 + def aligned_braces?(left_brace, right_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:130 + def braces_with_contents_inside(node, inner); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:105 + def check_inside(node, left_brace, right_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:137 + def check_left_brace(inner, left_brace, args_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:145 + def check_right_brace(inner, left_brace, right_brace, single_line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:156 + def multiline_block?(left_brace, right_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:206 + def no_space(begin_pos, end_pos, msg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:164 + def no_space_inside_left_brace(left_brace, args_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:222 + def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:196 + def pipe?(args_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:214 + def space(begin_pos, end_pos, msg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:181 + def space_inside_left_brace(left_brace, args_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:200 + def space_inside_right_brace(right_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_block_braces.rb:235 + def style_for_empty_braces; end +end + +# Checks that braces used for hash literals have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: space (default) +# # The `space` style enforces that hash literals have +# # surrounding space. +# +# # bad +# h = {a: 1, b: 2} +# +# # good +# h = { a: 1, b: 2 } +# @example EnforcedStyle: no_space +# # The `no_space` style enforces that hash literals have +# # no surrounding space. +# +# # bad +# h = { a: 1, b: 2 } +# +# # good +# h = {a: 1, b: 2} +# @example EnforcedStyle: compact +# # The `compact` style normally requires a space inside +# # hash braces, with the exception that successive left +# # braces or right braces are collapsed together in nested hashes. +# +# # bad +# h = { a: { b: 2 } } +# foo = { { a: 1 } => { b: { c: 2 } } } +# +# # good +# h = { a: { b: 2 }} +# foo = {{ a: 1 } => { b: { c: 2 }}} +# @example EnforcedStyleForEmptyBraces: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBraces style enforces that +# # empty hash braces do not contain spaces. +# +# # bad +# foo = { } +# bar = { } +# +# # good +# foo = {} +# bar = {} +# @example EnforcedStyleForEmptyBraces: space +# # The `space` EnforcedStyleForEmptyBraces style enforces that +# # empty hash braces contain space. +# +# # bad +# foo = {} +# +# # good +# foo = { } +# foo = { } +# foo = { } +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:66 +class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:74 + def on_hash(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:132 + def ambiguous_or_unexpected_style_detected(style, is_match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:124 + def autocorrect(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:84 + def check(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:99 + def expect_space?(token1, token2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:112 + def incorrect_style_detected(token1, token2, expect_space, is_empty_braces); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:145 + def message(brace, is_empty_braces, expect_space); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:140 + def offense?(token1, expect_space); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:171 + def range_of_space_to_the_left(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:163 + def range_of_space_to_the_right(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:155 + def space_range(token_range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb:72 +RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::MSG = T.let(T.unsafe(nil), String) + +# Checks for spaces inside ordinary round parentheses. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that parentheses do not have spaces. +# +# # bad +# f( 3) +# g = (a + 3 ) +# f( ) +# +# # good +# f(3) +# g = (a + 3) +# f() +# @example EnforcedStyle: space +# # The `space` style enforces that parentheses have a space at the +# # beginning and end. +# # Note: Empty parentheses should not have spaces. +# +# # bad +# f(3) +# g = (a + 3) +# y( ) +# +# # good +# f( 3 ) +# g = ( a + 3 ) +# y() +# @example EnforcedStyle: compact +# # The `compact` style enforces that parentheses have a space at the +# # beginning with the exception that successive parentheses are allowed. +# # Note: Empty parentheses should not have spaces. +# +# # bad +# f(3) +# g = (a + 3) +# y( ) +# g( f( x ) ) +# g( f( x( 3 ) ), 5 ) +# g( ( ( 3 + 5 ) * f) ** x, 5 ) +# +# # good +# f( 3 ) +# g = ( a + 3 ) +# y() +# g( f( x )) +# g( f( x( 3 )), 5 ) +# g((( 3 + 5 ) * f ) ** x, 5 ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:57 +class RuboCop::Cop::Layout::SpaceInsideParens < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:66 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:161 + def can_be_ignored?(token1, token2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:115 + def correct_extaneus_space_between_consecutive_parens(token1, token2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:99 + def correct_extraneous_space(tokens); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:124 + def correct_extraneous_space_in_empty_parens(token1, token2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:135 + def correct_missing_space(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:153 + def left_parens?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:149 + def parens?(token1, token2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:88 + def process_with_compact_style(tokens); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:81 + def process_with_space_style(tokens); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:157 + def right_parens?(token1, token2); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:63 +RuboCop::Cop::Layout::SpaceInsideParens::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_parens.rb:64 +RuboCop::Cop::Layout::SpaceInsideParens::MSG_SPACE = T.let(T.unsafe(nil), String) + +# Checks for unnecessary additional spaces inside the delimiters of +# %i/%w/%x literals. +# +# @example +# +# # good +# %i(foo bar baz) +# +# # bad +# %w( foo bar baz ) +# +# # bad +# %x( ls -l ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:19 +class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:28 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:36 + def on_percent_literal(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:32 + def on_xstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:42 + def add_offenses_for_unnecessary_spaces(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:52 + def regex_matches(node, &blk); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:25 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BEGIN_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:26 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::END_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb:24 +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::MSG = T.let(T.unsafe(nil), String) + +# Checks for spaces inside range literals. +# +# @example +# # bad +# 1 .. 3 +# +# # good +# 1..3 +# +# # bad +# 'a' .. 'z' +# +# # good +# 'a'..'z' +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_range_literal.rb:20 +class RuboCop::Cop::Layout::SpaceInsideRangeLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_range_literal.rb:29 + def on_erange(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_range_literal.rb:25 + def on_irange(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_range_literal.rb:35 + def check(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_range_literal.rb:23 +RuboCop::Cop::Layout::SpaceInsideRangeLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks that reference brackets have or don't have +# surrounding space depending on configuration. +# +# @example EnforcedStyle: no_space (default) +# # The `no_space` style enforces that reference brackets have +# # no surrounding space. +# +# # bad +# hash[ :key ] +# array[ index ] +# +# # good +# hash[:key] +# array[index] +# @example EnforcedStyle: space +# # The `space` style enforces that reference brackets have +# # surrounding space. +# +# # bad +# hash[:key] +# array[index] +# +# # good +# hash[ :key ] +# array[ index ] +# @example EnforcedStyleForEmptyBrackets: no_space (default) +# # The `no_space` EnforcedStyleForEmptyBrackets style enforces that +# # empty reference brackets do not contain spaces. +# +# # bad +# foo[ ] +# foo[ ] +# +# # good +# foo[] +# @example EnforcedStyleForEmptyBrackets: space +# # The `space` EnforcedStyleForEmptyBrackets style enforces that +# # empty reference brackets contain exactly one space. +# +# # bad +# foo[] +# foo[ ] +# +# # good +# foo[ ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:56 +class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:66 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:88 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:117 + def closing_bracket(tokens, opening_bracket); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:133 + def empty_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:106 + def left_ref_bracket(node, tokens); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:128 + def previous_token(current_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:100 + def reference_brackets(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:62 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::EMPTY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:61 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_reference_brackets.rb:64 +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for whitespace within string interpolations. +# +# @example EnforcedStyle: no_space (default) +# # bad +# var = "This is the #{ space } example" +# +# # good +# var = "This is the #{no_space} example" +# @example EnforcedStyle: space +# # bad +# var = "This is the #{no_space} example" +# +# # good +# var = "This is the #{ space } example" +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:21 +class RuboCop::Cop::Layout::SpaceInsideStringInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:31 + def on_interpolation(begin_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:46 + def autocorrect(corrector, begin_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:56 + def delimiters(begin_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:28 +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/space_inside_string_interpolation.rb:29 +RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_MSG = T.let(T.unsafe(nil), String) + +# Looks for trailing blank lines and a final newline in the +# source code. +# +# @example EnforcedStyle: final_newline (default) +# # `final_newline` looks for one newline at the end of files. +# +# # bad +# class Foo; end +# +# # EOF +# +# # bad +# class Foo; end # EOF +# +# # good +# class Foo; end +# # EOF +# @example EnforcedStyle: final_blank_line +# # `final_blank_line` looks for one blank line followed by a new line +# # at the end of files. +# +# # bad +# class Foo; end +# # EOF +# +# # bad +# class Foo; end # EOF +# +# # good +# class Foo; end +# +# # EOF +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_empty_lines.rb:40 +class RuboCop::Cop::Layout::TrailingEmptyLines < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_empty_lines.rb:45 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_empty_lines.rb:79 + def ends_in_end?(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_empty_lines.rb:89 + def message(wanted_blank_lines, blank_lines); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_empty_lines.rb:66 + def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end); end +end + +# Looks for trailing whitespace in the source code. +# +# @example +# # The line in this example contains spaces after the 0. +# # bad +# x = 0 +# +# # The line in this example ends directly after the 0. +# # good +# x = 0 +# @example AllowInHeredoc: false (default) +# # The line in this example contains spaces after the 0. +# # bad +# code = <<~RUBY +# x = 0 +# RUBY +# +# # ok +# code = <<~RUBY +# x = 0 #{} +# RUBY +# +# # good +# trailing_whitespace = ' ' +# code = <<~RUBY +# x = 0#{trailing_whitespace} +# RUBY +# @example AllowInHeredoc: true +# # The line in this example contains spaces after the 0. +# # good +# code = <<~RUBY +# x = 0 +# RUBY +# +# source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:42 +class RuboCop::Cop::Layout::TrailingWhitespace < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Heredoc + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:58 + def on_heredoc(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:49 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:109 + def extract_heredocs(ast); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:104 + def find_heredoc(line_number); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:118 + def offense_range(lineno, line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:62 + def process_line(line, lineno); end + + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:76 + def process_line_in_heredoc(corrector, range, heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:100 + def skip_heredoc?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:96 + def static?(heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:87 + def whitespace_is_indentation?(range, level); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:91 + def whitespace_only?(range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/layout/trailing_whitespace.rb:47 +RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:5 +module RuboCop::Cop::Legacy; end + +# Legacy support for Corrector#corrections +# See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html +# +# source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:8 +class RuboCop::Cop::Legacy::CorrectionsProxy + # @return [CorrectionsProxy] a new instance of CorrectionsProxy + # + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:9 + def initialize(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:13 + def <<(callable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:21 + def concat(corrections); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:17 + def empty?; end + + protected + + # Returns the value of attribute corrector. + # + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:31 + def corrector; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/legacy/corrections_proxy.rb:35 + def suppress_clobbering; end +end + +# This class handles autocorrection for code that needs to be moved +# to new lines. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:7 +class RuboCop::Cop::LineBreakCorrector + extend ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::TrailingBody + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:27 + def break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:15 + def correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:35 + def move_comment(eol_comment:, node:, corrector:); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:13 + def processed_source; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:45 + def remove_semicolon(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:51 + def semicolon(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/line_break_corrector.rb:58 + def trailing_class_definition?(token, body); end + end +end + +# Help methods for determining if a line is too long. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:6 +module RuboCop::Cop::LineLengthHelp + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:22 + def allow_uri?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:26 + def allowed_uri_position?(line, uri_range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:13 + def directive_on_source_line?(line_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:63 + def extend_uri_end_position(line, end_position); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:34 + def find_excessive_uri_range(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:9 + def ignore_cop_directives?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:57 + def indentation_difference(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:30 + def line_length(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:96 + def line_length_without_directive(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:49 + def match_uris(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:79 + def tab_indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:84 + def uri_regexp; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/line_length_help.rb:89 + def valid_uri?(uri_ish_string); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/unused_argument.rb:5 +module RuboCop::Cop::Lint; end + +# Checks for mistyped shorthand assignments. +# +# @example +# # bad +# x =- y +# x =+ y +# x =* y +# x =! y +# +# # good +# x -= y # or x = -y +# x += y # or x = +y +# x *= y # or x = *y +# x != y # or x = !y +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:21 +class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:30 + def on_lvasgn(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:44 + def rhs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:28 +RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:24 +RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_assignment.rb:26 +RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# Checks for ambiguous block association with method +# when param passed without parentheses. +# +# This cop can customize allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# @example +# +# # bad +# some_method a { |val| puts val } +# @example +# +# # good +# # With parentheses, there's no ambiguity. +# some_method(a { |val| puts val }) +# # or (different meaning) +# some_method(a) { |val| puts val } +# +# # good +# # Operator methods require no disambiguation +# foo == bar { |b| b.baz } +# +# # good +# # Lambda arguments require no disambiguation +# foo = ->(bar) { bar.baz } +# @example AllowedMethods: [] (default) +# +# # bad +# expect { do_something }.to change { object.attribute } +# @example AllowedMethods: [change] +# +# # good +# expect { do_something }.to change { object.attribute } +# @example AllowedPatterns: [] (default) +# +# # bad +# expect { do_something }.to change { object.attribute } +# @example AllowedPatterns: [/change/] +# +# # good +# expect { do_something }.to change { object.attribute } +# expect { do_something }.to not_change { object.attribute } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:54 +class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:62 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:62 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:81 + def allowed_method_pattern?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:77 + def ambiguous_block_association?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:87 + def message(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_block_association.rb:58 +RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String) + +# Checks for ambiguous operators in the first argument of a +# method invocation without parentheses. +# +# @example +# +# # bad +# +# # The `*` is interpreted as a splat operator but it could possibly be +# # a `*` method invocation (i.e. `do_something.*(some_array)`). +# do_something *some_array +# @example +# +# # good +# +# # With parentheses, there's no ambiguity. +# do_something(*some_array) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:23 +class RuboCop::Cop::Lint::AmbiguousOperator < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:41 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:60 + def find_offense_node_by(diagnostic); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:78 + def message(diagnostic); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:88 + def offense_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:84 + def offense_position?(node, diagnostic); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:97 + def unary_operator?(node, diagnostic); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:26 +RuboCop::Cop::Lint::AmbiguousOperator::AMBIGUITIES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator.rb:36 +RuboCop::Cop::Lint::AmbiguousOperator::MSG_FORMAT = T.let(T.unsafe(nil), String) + +# Looks for expressions containing multiple binary operators +# where precedence is ambiguous due to lack of parentheses. For example, +# in `1 + 2 * 3`, the multiplication will happen before the addition, but +# lexically it appears that the addition will happen first. +# +# The cop does not consider unary operators (ie. `!a` or `-b`) or comparison +# operators (ie. `a =~ b`) because those are not ambiguous. +# +# NOTE: Ranges are handled by `Lint/AmbiguousRange`. +# +# @example +# # bad +# a + b * c +# a || b && c +# a ** b + c +# +# # good (different precedence) +# a + (b * c) +# a || (b && c) +# (a ** b) + c +# +# # good (same precedence) +# a + b + c +# a * b / c % d +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:30 +class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:54 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:47 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:65 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:105 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:89 + def greater_precedence?(node1, node2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:85 + def operator?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:97 + def operator_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:79 + def precedence(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:45 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::MSG = T.let(T.unsafe(nil), String) + +# See https://ruby-doc.org/core-3.0.2/doc/syntax/precedence_rdoc.html +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:34 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::PRECEDENCE = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:44 +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for ambiguous ranges. +# +# Ranges have quite low precedence, which leads to unexpected behavior when +# using a range with other operators. This cop avoids that by making ranges +# explicit by requiring parenthesis around complex range boundaries (anything +# that is not a literal: numerics, strings, symbols, etc.). +# +# This cop can be configured with `RequireParenthesesForMethodChains` in order to +# specify whether method chains (including `self.foo`) should be wrapped in parens +# by this cop. +# +# NOTE: Regardless of this configuration, if a method receiver is a basic literal +# value, it will be wrapped in order to prevent the ambiguity of `1..2.to_a`. +# +# @example +# # bad +# x || 1..2 +# (x || 1..2) +# 1..2.to_a +# +# # good, unambiguous +# 1..2 +# 'a'..'z' +# :bar..:baz +# MyClass::MIN..MyClass::MAX +# @min..@max +# a..b +# -a..b +# +# # good, ambiguity removed +# x || (1..2) +# (x || 1)..2 +# (x || 1)..(y || 2) +# (1..2).to_a +# @example RequireParenthesesForMethodChains: false (default) +# # good +# a.foo..b.bar +# (a.foo)..(b.bar) +# @example RequireParenthesesForMethodChains: true +# # bad +# a.foo..b.bar +# +# # good +# (a.foo)..(b.bar) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:59 +class RuboCop::Cop::Lint::AmbiguousRange < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:64 + def on_erange(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:64 + def on_irange(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:82 + def acceptable?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:89 + def acceptable_call?(node); end + + # @yield [range.begin] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:77 + def each_boundary(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:99 + def require_parentheses_for_method_chain?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_range.rb:62 +RuboCop::Cop::Lint::AmbiguousRange::MSG = T.let(T.unsafe(nil), String) + +# Checks for ambiguous regexp literals in the first argument of +# a method invocation without parentheses. +# +# @example +# +# # bad +# +# # This is interpreted as a method invocation with a regexp literal, +# # but it could possibly be `/` method invocations. +# # (i.e. `do_something./(pattern)./(i)`) +# do_something /pattern/i +# @example +# +# # good +# +# # With parentheses, there's no ambiguity. +# do_something(/pattern/i) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:24 +class RuboCop::Cop::Lint::AmbiguousRegexpLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:31 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:56 + def find_offense_node(node, regexp_receiver); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:49 + def find_offense_node_by(diagnostic); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:67 + def first_argument_is_regexp?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:71 + def method_chain_to_regexp_receiver?(node, regexp_receiver); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb:27 +RuboCop::Cop::Lint::AmbiguousRegexpLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks for assignments in the conditions of +# if/while/until. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example +# # bad +# if some_var = true +# do_something +# end +# +# # good +# if some_var == true +# do_something +# end +# @example AllowSafeAssignment: true (default) +# # good +# if (some_var = true) +# do_something +# end +# @example AllowSafeAssignment: false +# # bad +# if (some_var = true) +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:37 +class RuboCop::Cop::Lint::AssignmentInCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:49 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:49 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:49 + def on_while(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:72 + def allowed_construct?(asgn_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:76 + def conditional_assignment?(asgn_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:64 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:80 + def skip_children?(asgn_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:86 + def traverse_node(node, &block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:47 +RuboCop::Cop::Lint::AssignmentInCondition::ASGN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:44 +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/assignment_in_condition.rb:40 +RuboCop::Cop::Lint::AssignmentInCondition::MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = T.let(T.unsafe(nil), String) + +# `BigDecimal.new()` is deprecated since BigDecimal 1.3.3. +# This cop identifies places where `BigDecimal.new()` +# can be replaced by `BigDecimal()`. +# +# @example +# # bad +# BigDecimal.new(123.456, 3) +# +# # good +# BigDecimal(123.456, 3) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/big_decimal_new.rb:17 +class RuboCop::Cop::Lint::BigDecimalNew < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/big_decimal_new.rb:25 + def big_decimal_new(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/big_decimal_new.rb:30 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/big_decimal_new.rb:20 +RuboCop::Cop::Lint::BigDecimalNew::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/big_decimal_new.rb:22 +RuboCop::Cop::Lint::BigDecimalNew::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where binary operator has identical operands. +# +# It covers arithmetic operators: `-`, `/`, `%`; +# comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`; +# bitwise operators: `|`, `^`, `&`; +# boolean operators: `&&`, `||` +# and "spaceship" operator - `<=>`. +# +# Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`. +# Although these can be rewritten in a different way, it should not be necessary to +# do so. This does not include operations such as `-` or `/` where the result will +# always be the same (`x - x` will always be 0; `x / x` will always be 1), and +# thus are legitimate offenses. +# +# @example +# # bad +# x / x +# x.top >= x.top +# +# if a.x != 0 && a.x != 0 +# do_something +# end +# +# def child? +# left_child || left_child +# end +# +# # good +# x + x +# 1 << 1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:48 +class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:61 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:61 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:52 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:50 +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::ALLOWED_MATH_OPERATORS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb:49 +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::MSG = T.let(T.unsafe(nil), String) + +# Checks for `:true` and `:false` symbols. +# In most cases it would be a typo. +# +# @example +# +# # bad +# :true +# +# # good +# true +# @example +# +# # bad +# :false +# +# # good +# false +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/boolean_symbol.rb:29 +class RuboCop::Cop::Lint::BooleanSymbol < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/boolean_symbol.rb:35 + def boolean_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/boolean_symbol.rb:37 + def on_sym(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/boolean_symbol.rb:50 + def autocorrect(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/boolean_symbol.rb:32 +RuboCop::Cop::Lint::BooleanSymbol::MSG = T.let(T.unsafe(nil), String) + +# Checks for circular argument references in optional keyword +# arguments and optional ordinal arguments. +# +# This cop mirrors a warning produced by MRI since 2.2. +# +# @example +# +# # bad +# +# def bake(pie: pie) +# pie.heat_up +# end +# @example +# +# # good +# +# def bake(pie:) +# pie.refrigerate +# end +# @example +# +# # good +# +# def bake(pie: self.pie) +# pie.feed_to(user) +# end +# @example +# +# # bad +# +# def cook(dry_ingredients = dry_ingredients) +# dry_ingredients.reduce(&:+) +# end +# @example +# +# # good +# +# def cook(dry_ingredients = self.dry_ingredients) +# dry_ingredients.combine +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/circular_argument_reference.rb:50 +class RuboCop::Cop::Lint::CircularArgumentReference < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/circular_argument_reference.rb:53 + def on_kwoptarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/circular_argument_reference.rb:57 + def on_optarg(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/circular_argument_reference.rb:63 + def check_for_circular_argument_references(arg_name, arg_value); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/circular_argument_reference.rb:51 +RuboCop::Cop::Lint::CircularArgumentReference::MSG = T.let(T.unsafe(nil), String) + +# Do not define constants within a block, since the block's scope does not +# isolate or namespace the constant in any way. +# +# If you are trying to define that constant once, define it outside of +# the block instead, or use a variable or method if defining the constant +# in the outer scope would be problematic. +# +# For meta-programming, use `const_set`. +# +# @example +# # bad +# task :lint do +# FILES_TO_LINT = Dir['lib/*.rb'] +# end +# +# # bad +# describe 'making a request' do +# class TestRequest; end +# end +# +# # bad +# module M +# extend ActiveSupport::Concern +# included do +# LIST = [] +# end +# end +# +# # good +# task :lint do +# files_to_lint = Dir['lib/*.rb'] +# end +# +# # good +# describe 'making a request' do +# let(:test_request) { Class.new } +# # see also `stub_const` for RSpec +# end +# +# # good +# module M +# extend ActiveSupport::Concern +# included do +# const_set(:LIST, []) +# end +# end +# @example AllowedMethods: ['enums'] (default) +# # good +# +# # `enums` for Typed Enums via `T::Enum` in Sorbet. +# # https://sorbet.org/docs/tenum +# class TestEnum < T::Enum +# enums do +# Foo = new("foo") +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:64 +class RuboCop::Cop::Lint::ConstantDefinitionInBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:70 + def constant_assigned_in_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:75 + def module_defined_in_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:79 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:85 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:85 + def on_module(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:94 + def method_name(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_definition_in_block.rb:67 +RuboCop::Cop::Lint::ConstantDefinitionInBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for overwriting an exception with an exception result by use `rescue =>`. +# +# You intended to write as `rescue StandardError`. +# However, you have written `rescue => StandardError`. +# In that case, the result of `rescue` will overwrite `StandardError`. +# +# @example +# +# # bad +# begin +# something +# rescue => StandardError +# end +# +# # good +# begin +# something +# rescue StandardError +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb:26 +class RuboCop::Cop::Lint::ConstantOverwrittenInRescue < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb:41 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb:33 + def overwritten_constant(param0 = T.unsafe(nil)); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb:37 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_overwritten_in_rescue.rb:30 +RuboCop::Cop::Lint::ConstantOverwrittenInRescue::MSG = T.let(T.unsafe(nil), String) + +# Check that certain constants are fully qualified. +# +# This is not enabled by default because it would mark a lot of offenses +# unnecessarily. +# +# Generally, gems should fully qualify all constants to avoid conflicts with +# the code that uses the gem. Enable this cop without using `Only`/`Ignore` +# +# Large projects will over time end up with one or two constant names that +# are problematic because of a conflict with a library or just internally +# using the same name a namespace and a class. To avoid too many unnecessary +# offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]` +# +# @example +# # By default checks every constant +# +# # bad +# User +# +# # bad +# User::Login +# +# # good +# ::User +# +# # good +# ::User::Login +# @example Only: ['Login'] +# # Restrict this cop to only being concerned about certain constants +# +# # bad +# Login +# +# # good +# ::Login +# +# # good +# User::Login +# @example Ignore: ['Login'] +# # Restrict this cop not being concerned about certain constants +# +# # bad +# User +# +# # good +# ::User::Login +# +# # good +# Login +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:58 +class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:66 + def on_const(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:62 + def unqualified_const?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:79 + def allowed_names; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:74 + def const_name?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:83 + def ignored_names; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/constant_resolution.rb:59 +RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String) + +# Checks for debug calls (such as `debugger` or `binding.pry`) that should +# not be kept for production code. +# +# The cop can be configured using `DebuggerMethods`. By default, a number of gems +# debug entrypoints are configured (`Kernel`, `Byebug`, `Capybara`, `debug.rb`, +# `Pry`, `Rails`, `RubyJard`, and `WebConsole`). Additional methods can be added. +# +# Specific default groups can be disabled if necessary: +# +# [source,yaml] +# ---- +# Lint/Debugger: +# DebuggerMethods: +# WebConsole: ~ +# ---- +# +# You can also add your own methods by adding a new category: +# +# [source,yaml] +# ---- +# Lint/Debugger: +# DebuggerMethods: +# MyDebugger: +# MyDebugger.debug_this +# ---- +# +# @example +# +# # bad (ok during development) +# +# # using pry +# def some_method +# binding.pry +# do_something +# end +# @example +# +# # bad (ok during development) +# +# # using byebug +# def some_method +# byebug +# do_something +# end +# @example +# +# # good +# +# def some_method +# do_something +# end +# @example DebuggerMethods: [my_debugger] +# +# # bad (ok during development) +# +# def some_method +# my_debugger +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:67 +class RuboCop::Cop::Lint::Debugger < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:70 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:98 + def debugger_method?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:82 + def debugger_methods; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:78 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:110 + def receiver_chain(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/debugger.rb:68 +RuboCop::Cop::Lint::Debugger::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the deprecated class method usages. +# +# @example +# +# # bad +# File.exists?(some_path) +# Dir.exists?(some_path) +# iterator? +# ENV.freeze # Calling `Env.freeze` raises `TypeError` since Ruby 2.7. +# ENV.clone +# ENV.dup # Calling `Env.dup` raises `TypeError` since Ruby 3.1. +# Socket.gethostbyname(host) +# Socket.gethostbyaddr(host) +# +# # good +# File.exist?(some_path) +# Dir.exist?(some_path) +# block_given? +# ENV # `ENV.freeze` cannot prohibit changes to environment variables. +# ENV.to_h +# ENV.to_h # `ENV.dup` cannot dup `ENV`, use `ENV.to_h` to get a copy of `ENV` as a hash. +# Addrinfo.getaddrinfo(nodename, service) +# Addrinfo.tcp(host, port).getnameinfo +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:29 +class RuboCop::Cop::Lint::DeprecatedClassMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:132 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:153 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:162 + def replacement(deprecated); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:129 +RuboCop::Cop::Lint::DeprecatedClassMethods::CLASS_METHOD_DELIMITER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:102 +RuboCop::Cop::Lint::DeprecatedClassMethods::DEPRECATED_METHODS_OBJECT = T.let(T.unsafe(nil), Hash) + +# Inner class to DeprecatedClassMethods. +# This class exists to add abstraction and clean naming +# to the deprecated objects +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:35 +class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod + include ::RuboCop::AST::Sexp + + # @return [DeprecatedClassMethod] a new instance of DeprecatedClassMethod + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:40 + def initialize(method, class_constant: T.unsafe(nil), correctable: T.unsafe(nil)); end + + # Returns the value of attribute class_constant. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:38 + def class_constant; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:46 + def class_nodes; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:58 + def correctable?; end + + # Returns the value of attribute method. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:38 + def method; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:62 + def to_s; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:68 + def delimiter; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:130 +RuboCop::Cop::Lint::DeprecatedClassMethods::INSTANCE_METHOD_DELIMITER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:100 +RuboCop::Cop::Lint::DeprecatedClassMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:127 +RuboCop::Cop::Lint::DeprecatedClassMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Inner class to DeprecatedClassMethods. +# This class exists to add abstraction and clean naming +# to the replacements for deprecated objects +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:76 +class RuboCop::Cop::Lint::DeprecatedClassMethods::Replacement + # @return [Replacement] a new instance of Replacement + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:79 + def initialize(method, class_constant: T.unsafe(nil), instance_method: T.unsafe(nil)); end + + # Returns the value of attribute class_constant. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:77 + def class_constant; end + + # Returns the value of attribute method. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:77 + def method; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:85 + def to_s; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:91 + def delimiter; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_class_methods.rb:95 + def instance_method?; end +end + +# Checks for deprecated constants. +# +# It has `DeprecatedConstants` config. If there is an alternative method, you can set +# alternative value as `Alternative`. And you can set the deprecated version as +# `DeprecatedVersion`. These options can be omitted if they are not needed. +# +# DeprecatedConstants: +# 'DEPRECATED_CONSTANT': +# Alternative: 'alternative_value' +# DeprecatedVersion: 'deprecated_version' +# +# By default, `NIL`, `TRUE`, `FALSE` and `Random::DEFAULT` are configured. +# +# @example +# +# # bad +# NIL +# TRUE +# FALSE +# Random::DEFAULT # Return value of Ruby 2 is `Random` instance, Ruby 3.0 is `Random` class. +# +# # good +# nil +# true +# false +# Random.new # `::DEFAULT` has been deprecated in Ruby 3, `.new` is compatible with Ruby 2. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:33 +class RuboCop::Cop::Lint::DeprecatedConstants < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:39 + def on_const(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:59 + def constant_name(node, nested_constant_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:75 + def deprecated_constants; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:65 + def message(good, bad, deprecated_version); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:37 +RuboCop::Cop::Lint::DeprecatedConstants::DO_NOT_USE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_constants.rb:36 +RuboCop::Cop::Lint::DeprecatedConstants::SUGGEST_GOOD_MSG = T.let(T.unsafe(nil), String) + +# Algorithmic constants for `OpenSSL::Cipher` and `OpenSSL::Digest` +# deprecated since OpenSSL version 2.2.0. Prefer passing a string +# instead. +# +# @example +# +# # Example for OpenSSL::Cipher instantiation. +# +# # bad +# OpenSSL::Cipher::AES.new(128, :GCM) +# +# # good +# OpenSSL::Cipher.new('aes-128-gcm') +# @example +# +# # Example for OpenSSL::Digest instantiation. +# +# # bad +# OpenSSL::Digest::SHA256.new +# +# # good +# OpenSSL::Digest.new('SHA256') +# @example +# +# # Example for ::Digest inherited class methods. +# +# # bad +# OpenSSL::Digest::SHA256.digest('foo') +# +# # good +# OpenSSL::Digest.digest('SHA256', 'foo') +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:40 +class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:49 + def algorithm_const(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:59 + def digest_const?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:63 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:110 + def algorithm_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:75 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:139 + def build_cipher_arguments(node, algorithm_name, no_arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:102 + def correction_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:87 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:106 + def openssl_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:128 + def replacement_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:120 + def sanitize_arguments(arguments); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:44 +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:46 +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::NO_ARG_ALGORITHM = T.let(T.unsafe(nil), Array) + +# Checks constructors for disjunctive assignments (`||=`) that should +# be plain assignments. +# +# So far, this cop is only concerned with disjunctive assignment of +# instance variables. +# +# In ruby, an instance variable is nil until a value is assigned, so the +# disjunction is unnecessary. A plain assignment has the same effect. +# +# @example +# # bad +# def initialize +# @x ||= 1 +# end +# +# # good +# def initialize +# @x = 1 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:48 +class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:53 + def on_def(node); end + + private + + # @param node [DefNode] a constructor definition + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:60 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:66 + def check_body(body); end + + # @param lines [Array] the logical lines of the constructor + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:78 + def check_body_lines(lines); end + + # Add an offense if the LHS of the given disjunctive assignment is + # an instance variable. + # + # For now, we only care about assignments to instance variables. + # + # @param node [Node] a disjunctive assignment + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:99 + def check_disjunctive_assignment(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/disjunctive_assignment_in_constructor.rb:51 +RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated bodies +# within `if/unless`, `case-when`, `case-in` and `rescue` constructs. +# +# With `IgnoreLiteralBranches: true`, branches are not registered +# as offenses if they return a basic literal value (string, symbol, +# integer, float, rational, complex, `true`, `false`, or `nil`), or +# return an array, hash, regexp or range that only contains one of +# the above basic literal values. +# +# With `IgnoreConstantBranches: true`, branches are not registered +# as offenses if they return a constant value. +# +# @example +# # bad +# if foo +# do_foo +# do_something_else +# elsif bar +# do_foo +# do_something_else +# end +# +# # good +# if foo || bar +# do_foo +# do_something_else +# end +# +# # bad +# case x +# when foo +# do_foo +# when bar +# do_foo +# else +# do_something_else +# end +# +# # good +# case x +# when foo, bar +# do_foo +# else +# do_something_else +# end +# +# # bad +# begin +# do_something +# rescue FooError +# handle_error +# rescue BarError +# handle_error +# end +# +# # good +# begin +# do_something +# rescue FooError, BarError +# handle_error +# end +# @example IgnoreLiteralBranches: true +# # good +# case size +# when "small" then 100 +# when "medium" then 250 +# when "large" then 1000 +# else 250 +# end +# @example IgnoreConstantBranches: true +# # good +# case size +# when "small" then SMALL_SIZE +# when "medium" then MEDIUM_SIZE +# when "large" then LARGE_SIZE +# else MEDIUM_SIZE +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:86 +class RuboCop::Cop::Lint::DuplicateBranch < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:91 + def on_branching_statement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:91 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:91 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:91 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:91 + def on_rescue(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:119 + def branches(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:123 + def consider_branch?(branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:149 + def const_branch?(branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:134 + def ignore_constant_branches?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:130 + def ignore_literal_branches?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:138 + def literal_branch?(branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:105 + def offense_range(duplicate_branch); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_branch.rb:89 +RuboCop::Cop::Lint::DuplicateBranch::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated conditions +# used in case 'when' expressions. +# +# @example +# +# # bad +# +# case x +# when 'first' +# do_something +# when 'first' +# do_something_else +# end +# @example +# +# # good +# +# case x +# when 'first' +# do_something +# when 'second' +# do_something_else +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_case_condition.rb:30 +class RuboCop::Cop::Lint::DuplicateCaseCondition < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_case_condition.rb:33 + def on_case(case_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_case_condition.rb:31 +RuboCop::Cop::Lint::DuplicateCaseCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks that there are no repeated conditions used in if 'elsif'. +# +# @example +# # bad +# if x == 1 +# do_something +# elsif x == 1 +# do_something_else +# end +# +# # good +# if x == 1 +# do_something +# elsif x == 2 +# do_something_else +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_elsif_condition.rb:23 +class RuboCop::Cop::Lint::DuplicateElsifCondition < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_elsif_condition.rb:26 + def on_if(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_elsif_condition.rb:24 +RuboCop::Cop::Lint::DuplicateElsifCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for duplicated keys in hash literals. +# +# This cop mirrors a warning in Ruby 2.2. +# +# @example +# +# # bad +# +# hash = { food: 'apple', food: 'orange' } +# @example +# +# # good +# +# hash = { food: 'apple', other_food: 'orange' } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_hash_key.rb:21 +class RuboCop::Cop::Lint::DuplicateHashKey < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Duplication + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_hash_key.rb:26 + def on_hash(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_hash_key.rb:24 +RuboCop::Cop::Lint::DuplicateHashKey::MSG = T.let(T.unsafe(nil), String) + +# Checks for duplicated instance (or singleton) method +# definitions. +# +# @example +# +# # bad +# +# def foo +# 1 +# end +# +# def foo +# 2 +# end +# @example +# +# # bad +# +# def foo +# 1 +# end +# +# alias foo bar +# @example +# +# # good +# +# def foo +# 1 +# end +# +# def bar +# 2 +# end +# @example +# +# # good +# +# def foo +# 1 +# end +# +# alias bar foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:52 +class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base + # @return [DuplicateMethods] a new instance of DuplicateMethods + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:57 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:97 + def alias_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:84 + def method_alias?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:88 + def on_alias(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:62 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:71 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:103 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:102 + def sym_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:116 + def check_const_receiver(node, name, const_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:123 + def check_self_receiver(node, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:178 + def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:135 + def found_instance_method(node, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:148 + def found_method(node, method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:188 + def lookup_constant(node, const_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:130 + def message_for_dup(node, method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:164 + def on_attr(node, attr_name, args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:220 + def possible_dsl?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:206 + def qualified_name(enclosing, namespace, mod_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:230 + def source_location(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:53 +RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_methods.rb:55 +RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for duplicate elements in Regexp character classes. +# +# @example +# +# # bad +# r = /[xyx]/ +# +# # bad +# r = /[0-9x0-9]/ +# +# # good +# r = /[xy]/ +# +# # good +# r = /[0-9x]/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:21 +class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:35 + def each_repeated_character_class_element_loc(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:27 + def on_regexp(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:64 + def interpolation_locs(node); end + + # Since we blank interpolations with a space for every char of the interpolation, we would + # mark every space (except the first) as duplicate if we do not skip regexp_parser nodes + # that are within an interpolation. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:58 + def within_interpolation?(node, child); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_regexp_character_class_element.rb:25 +RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::MSG_REPEATED_ELEMENT = T.let(T.unsafe(nil), String) + +# Checks for duplicate `require`s and `require_relative`s. +# +# @example +# # bad +# require 'foo' +# require 'bar' +# require 'foo' +# +# # good +# require 'foo' +# require 'bar' +# +# # good +# require 'foo' +# require_relative 'foo' +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:26 +class RuboCop::Cop::Lint::DuplicateRequire < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:39 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:45 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:35 + def require_call?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:30 +RuboCop::Cop::Lint::DuplicateRequire::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:31 +RuboCop::Cop::Lint::DuplicateRequire::REQUIRE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_require.rb:32 +RuboCop::Cop::Lint::DuplicateRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks that there are no repeated exceptions +# used in 'rescue' expressions. +# +# @example +# # bad +# begin +# something +# rescue FirstException +# handle_exception +# rescue FirstException +# handle_other_exception +# end +# +# # good +# begin +# something +# rescue FirstException +# handle_exception +# rescue SecondException +# handle_other_exception +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_rescue_exception.rb:28 +class RuboCop::Cop::Lint::DuplicateRescueException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_rescue_exception.rb:33 + def on_rescue(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/duplicate_rescue_exception.rb:31 +RuboCop::Cop::Lint::DuplicateRescueException::MSG = T.let(T.unsafe(nil), String) + +# Checks if each_with_object is called with an immutable +# argument. Since the argument is the object that the given block shall +# make calls on to build something based on the enumerable that +# each_with_object iterates over, an immutable argument makes no sense. +# It's definitely a bug. +# +# @example +# +# # bad +# +# sum = numbers.each_with_object(0) { |e, a| a += e } +# @example +# +# # good +# +# num = 0 +# sum = numbers.each_with_object(num) { |e, a| a += e } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:24 +class RuboCop::Cop::Lint::EachWithObjectArgument < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:29 + def each_with_object?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:33 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:33 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:25 +RuboCop::Cop::Lint::EachWithObjectArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/each_with_object_argument.rb:26 +RuboCop::Cop::Lint::EachWithObjectArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for odd `else` block layout - like +# having an expression on the same line as the `else` keyword, +# which is usually a mistake. +# +# Its autocorrection tweaks layout to keep the syntax. So, this autocorrection +# is compatible correction for bad case syntax, but if your code makes a mistake +# with `elsif` and `else`, you will have to correct it manually. +# +# @example +# +# # bad +# +# if something +# # ... +# else do_this +# do_that +# end +# @example +# +# # good +# +# # This code is compatible with the bad case. It will be autocorrected like this. +# if something +# # ... +# else +# do_this +# do_that +# end +# +# # This code is incompatible with the bad case. +# # If `do_this` is a condition, `elsif` should be used instead of `else`. +# if something +# # ... +# elsif do_this +# do_that +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:43 +class RuboCop::Cop::Lint::ElseLayout < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:49 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:80 + def autocorrect(corrector, node, first_else); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:60 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:70 + def check_else(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:88 + def indentation_width; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/else_layout.rb:47 +RuboCop::Cop::Lint::ElseLayout::MSG = T.let(T.unsafe(nil), String) + +# Checks for blocks without a body. +# Such empty blocks are typically an oversight or we should provide a comment +# be clearer what we're aiming for. +# +# Empty lambdas and procs are ignored by default. +# +# NOTE: For backwards compatibility, the configuration that allows/disallows +# empty lambdas and procs is called `AllowEmptyLambdas`, even though it also +# applies to procs. +# +# @example +# # bad +# items.each { |item| } +# +# # good +# items.each { |item| puts item } +# @example AllowComments: true (default) +# # good +# items.each do |item| +# # TODO: implement later (inner comment) +# end +# +# items.each { |item| } # TODO: implement later (inline comment) +# @example AllowComments: false +# # bad +# items.each do |item| +# # TODO: implement later (inner comment) +# end +# +# items.each { |item| } # TODO: implement later (inline comment) +# @example AllowEmptyLambdas: true (default) +# # good +# allow(subject).to receive(:callable).and_return(-> {}) +# +# placeholder = lambda do +# end +# (callable || placeholder).call +# +# proc { } +# +# Proc.new { } +# @example AllowEmptyLambdas: false +# # bad +# allow(subject).to receive(:callable).and_return(-> {}) +# +# placeholder = lambda do +# end +# (callable || placeholder).call +# +# proc { } +# +# Proc.new { } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:63 +class RuboCop::Cop::Lint::EmptyBlock < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:66 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:76 + def allow_comment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:83 + def allow_empty_lambdas?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:87 + def comment_disables_cop?(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:92 + def lambda_or_proc?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_block.rb:64 +RuboCop::Cop::Lint::EmptyBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for classes and metaclasses without a body. +# Such empty classes and metaclasses are typically an oversight or we should provide a comment +# to be clearer what we're aiming for. +# +# @example +# # bad +# class Foo +# end +# +# class Bar +# class << self +# end +# end +# +# class << obj +# end +# +# # good +# class Foo +# def do_something +# # ... code +# end +# end +# +# class Bar +# class << self +# attr_reader :bar +# end +# end +# +# class << obj +# attr_reader :bar +# end +# @example AllowComments: false (default) +# # bad +# class Foo +# # TODO: implement later +# end +# +# class Bar +# class << self +# # TODO: implement later +# end +# end +# +# class << obj +# # TODO: implement later +# end +# @example AllowComments: true +# # good +# class Foo +# # TODO: implement later +# end +# +# class Bar +# class << self +# # TODO: implement later +# end +# end +# +# class << obj +# # TODO: implement later +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:72 +class RuboCop::Cop::Lint::EmptyClass < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:76 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:81 + def on_sclass(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:87 + def body_or_allowed_comment_lines?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:73 +RuboCop::Cop::Lint::EmptyClass::CLASS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_class.rb:74 +RuboCop::Cop::Lint::EmptyClass::METACLASS_MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `if`, `elsif` and `unless` branches without a body. +# +# NOTE: empty `else` branches are handled by `Style/EmptyElse`. +# +# @example +# # bad +# if condition +# end +# +# # bad +# unless condition +# end +# +# # bad +# if condition +# do_something +# elsif other_condition +# end +# +# # good +# if condition +# do_something +# end +# +# # good +# unless condition +# do_something +# end +# +# # good +# if condition +# do_something +# elsif other_condition +# do_something_else +# end +# @example AllowComments: true (default) +# # good +# if condition +# do_something +# elsif other_condition +# # noop +# end +# @example AllowComments: false +# # bad +# if condition +# do_something +# elsif other_condition +# # noop +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:63 +class RuboCop::Cop::Lint::EmptyConditionalBody < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:70 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:81 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:110 + def branch_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:98 + def correct_other_branches(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:118 + def deletion_range(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:87 + def remove_comments(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:94 + def remove_empty_branch(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_conditional_body.rb:68 +RuboCop::Cop::Lint::EmptyConditionalBody::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty `ensure` blocks +# +# @example +# +# # bad +# +# def some_method +# do_something +# ensure +# end +# @example +# +# # bad +# +# begin +# do_something +# ensure +# end +# @example +# +# # good +# +# def some_method +# do_something +# ensure +# do_something_else +# end +# @example +# +# # good +# +# begin +# do_something +# ensure +# do_something_else +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_ensure.rb:45 +class RuboCop::Cop::Lint::EmptyEnsure < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_ensure.rb:50 + def on_ensure(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_ensure.rb:48 +RuboCop::Cop::Lint::EmptyEnsure::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of empty expressions. +# +# @example +# +# # bad +# +# foo = () +# if () +# bar +# end +# @example +# +# # good +# +# foo = (some_expression) +# if (some_expression) +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_expression.rb:25 +class RuboCop::Cop::Lint::EmptyExpression < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_expression.rb:28 + def on_begin(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_expression.rb:36 + def empty_expression?(begin_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_expression.rb:26 +RuboCop::Cop::Lint::EmptyExpression::MSG = T.let(T.unsafe(nil), String) + +# Enforces that Ruby source files are not empty. +# +# @example +# # bad +# # Empty file +# +# # good +# # File containing non commented source lines +# @example AllowComments: true (default) +# # good +# # File consisting only of comments +# @example AllowComments: false +# # bad +# # File consisting only of comments +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:23 +class RuboCop::Cop::Lint::EmptyFile < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:28 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:42 + def contains_only_comments?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:38 + def empty_file?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:34 + def offending?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_file.rb:26 +RuboCop::Cop::Lint::EmptyFile::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `in` pattern branches without a body. +# +# @example +# +# # bad +# case condition +# in [a] +# do_something +# in [a, b] +# end +# +# # good +# case condition +# in [a] +# do_something +# in [a, b] +# nil +# end +# @example AllowComments: true (default) +# +# # good +# case condition +# in [a] +# do_something +# in [a, b] +# # noop +# end +# @example AllowComments: false +# +# # bad +# case condition +# in [a] +# do_something +# in [a, b] +# # noop +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_in_pattern.rb:45 +class RuboCop::Cop::Lint::EmptyInPattern < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_in_pattern.rb:53 + def on_case_match(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_in_pattern.rb:49 +RuboCop::Cop::Lint::EmptyInPattern::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty interpolation. +# +# @example +# +# # bad +# +# "result is #{}" +# @example +# +# # good +# +# "result is #{some_result}" +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_interpolation.rb:19 +class RuboCop::Cop::Lint::EmptyInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_interpolation.rb:25 + def on_interpolation(begin_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_interpolation.rb:23 +RuboCop::Cop::Lint::EmptyInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of `when` branches without a body. +# +# @example +# +# # bad +# case foo +# when bar +# do_something +# when baz +# end +# @example +# +# # good +# case condition +# when foo +# do_something +# when bar +# nil +# end +# @example AllowComments: true (default) +# +# # good +# case condition +# when foo +# do_something +# when bar +# # noop +# end +# @example AllowComments: false +# +# # bad +# case condition +# when foo +# do_something +# when bar +# # do nothing +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_when.rb:47 +class RuboCop::Cop::Lint::EmptyWhen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_when.rb:52 + def on_case(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/empty_when.rb:50 +RuboCop::Cop::Lint::EmptyWhen::MSG = T.let(T.unsafe(nil), String) + +# Checks for `return` from an `ensure` block. +# `return` from an ensure block is a dangerous code smell as it +# will take precedence over any exception being raised, +# and the exception will be silently thrown away as if it were rescued. +# +# If you want to rescue some (or all) exceptions, best to do it explicitly +# +# @example +# +# # bad +# +# def foo +# do_something +# ensure +# cleanup +# return self +# end +# @example +# +# # good +# +# def foo +# do_something +# self +# ensure +# cleanup +# end +# +# # also good +# +# def foo +# begin +# do_something +# rescue SomeException +# # Let's ignore this exception +# end +# self +# ensure +# cleanup +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ensure_return.rb:47 +class RuboCop::Cop::Lint::EnsureReturn < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ensure_return.rb:53 + def on_ensure(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ensure_return.rb:51 +RuboCop::Cop::Lint::EnsureReturn::MSG = T.let(T.unsafe(nil), String) + +# This cop emulates the following Ruby warnings in Ruby 2.6. +# +# [source,console] +# ---- +# % cat example.rb +# ERB.new('hi', nil, '-', '@output_buffer') +# % ruby -rerb example.rb +# example.rb:1: warning: Passing safe_level with the 2nd argument of ERB.new is +# deprecated. Do not use it, and specify other arguments as keyword arguments. +# example.rb:1: warning: Passing trim_mode with the 3rd argument of ERB.new is +# deprecated. Use keyword argument like ERB.new(str, trim_mode:...) instead. +# example.rb:1: warning: Passing eoutvar with the 4th argument of ERB.new is +# deprecated. Use keyword argument like ERB.new(str, eoutvar: ...) instead. +# ---- +# +# Now non-keyword arguments other than first one are softly deprecated +# and will be removed when Ruby 2.5 becomes EOL. +# `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0. +# Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`. +# This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can +# be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`. +# +# @example +# # Target codes supports Ruby 2.6 and higher only +# # bad +# ERB.new(str, nil, '-', '@output_buffer') +# +# # good +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# +# # Target codes supports Ruby 2.5 and lower only +# # good +# ERB.new(str, nil, '-', '@output_buffer') +# +# # Target codes supports Ruby 2.6, 2.5 and lower +# # bad +# ERB.new(str, nil, '-', '@output_buffer') +# +# # good +# # Ruby standard library style +# # https://github.com/ruby/ruby/commit/3406c5d +# if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+ +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# else +# ERB.new(str, nil, '-', '@output_buffer') +# end +# +# # good +# # Use `RUBY_VERSION` style +# if RUBY_VERSION >= '2.6' +# ERB.new(str, trim_mode: '-', eoutvar: '@output_buffer') +# else +# ERB.new(str, nil, '-', '@output_buffer') +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:62 +class RuboCop::Cop::Lint::ErbNewArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:84 + def erb_new_with_non_keyword_arguments(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:89 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:154 + def arguments_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:109 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:124 + def build_kwargs(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:120 + def correct_arguments?(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:141 + def override_by_legacy_args(kwargs, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:69 +RuboCop::Cop::Lint::ErbNewArguments::MESSAGES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/erb_new_arguments.rb:81 +RuboCop::Cop::Lint::ErbNewArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for uses of flip-flop operator +# based on the Ruby Style Guide. +# +# Here is the history of flip-flops in Ruby. +# flip-flop operator is deprecated in Ruby 2.6.0 and +# the deprecation has been reverted by Ruby 2.7.0 and +# backported to Ruby 2.6. +# See: https://bugs.ruby-lang.org/issues/5400 +# +# @example +# # bad +# (1..20).each do |x| +# puts x if (x == 5) .. (x == 10) +# end +# +# # good +# (1..20).each do |x| +# puts x if (x >= 5) && (x <= 10) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/flip_flop.rb:25 +class RuboCop::Cop::Lint::FlipFlop < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/flip_flop.rb:32 + def on_eflipflop(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/flip_flop.rb:28 + def on_iflipflop(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/flip_flop.rb:26 +RuboCop::Cop::Lint::FlipFlop::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of precise comparison of floating point numbers. +# +# Floating point values are inherently inaccurate, and comparing them for exact equality +# is almost never the desired semantics. Comparison via the `==/!=` operators checks +# floating-point value representation to be exactly the same, which is very unlikely +# if you perform any arithmetic operations involving precision loss. +# +# @example +# # bad +# x == 0.1 +# x != 0.1 +# +# # good - using BigDecimal +# x.to_d == 0.1.to_d +# +# # good +# (x - 0.1).abs < Float::EPSILON +# +# # good +# tolerance = 0.0001 +# (x - 0.1).abs < tolerance +# +# # Or some other epsilon based type of comparison: +# # https://www.embeddeduse.com/2019/08/26/qt-compare-two-floats/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:31 +class RuboCop::Cop::Lint::FloatComparison < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:40 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:79 + def check_numeric_returning_method(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:63 + def check_send(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:47 + def float?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:34 +RuboCop::Cop::Lint::FloatComparison::EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:36 +RuboCop::Cop::Lint::FloatComparison::FLOAT_INSTANCE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:35 +RuboCop::Cop::Lint::FloatComparison::FLOAT_RETURNING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:32 +RuboCop::Cop::Lint::FloatComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_comparison.rb:38 +RuboCop::Cop::Lint::FloatComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies Float literals which are, like, really really really +# really really really really really big. Too big. No-one needs Floats +# that big. If you need a float that big, something is wrong with you. +# +# @example +# +# # bad +# +# float = 3.0e400 +# @example +# +# # good +# +# float = 42.9 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_out_of_range.rb:21 +class RuboCop::Cop::Lint::FloatOutOfRange < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/float_out_of_range.rb:24 + def on_float(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/float_out_of_range.rb:22 +RuboCop::Cop::Lint::FloatOutOfRange::MSG = T.let(T.unsafe(nil), String) + +# This lint sees if there is a mismatch between the number of +# expected fields for format/sprintf/#% and what is actually +# passed as arguments. +# +# In addition it checks whether different formats are used in the same +# format string. Do not mix numbered, unnumbered, and named formats in +# the same format string. +# +# @example +# +# # bad +# +# format('A value: %s and another: %i', a_value) +# @example +# +# # good +# +# format('A value: %s and another: %i', a_value, another) +# @example +# +# # bad +# +# format('Unnumbered format: %s and numbered: %2$s', a_value, another) +# @example +# +# # good +# +# format('Numbered format: %1$s and numbered %2$s', a_value, another) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:38 +class RuboCop::Cop::Lint::FormatParameterMismatch < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:96 + def called_on_string?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:49 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:133 + def count_format_matches(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:115 + def count_matches(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:137 + def count_percent_matches(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:125 + def countable_format?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:129 + def countable_percent?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:149 + def expected_fields_count(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:164 + def format?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:142 + def format_method?(name, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:64 + def format_string?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:111 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:68 + def invalid_format_string?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:87 + def matched_arguments_count?(expected, passed); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:183 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:101 + def method_with_format_args?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:77 + def offending_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:172 + def percent?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:105 + def splat_args?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:168 + def sprintf?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:44 +RuboCop::Cop::Lint::FormatParameterMismatch::KERNEL = T.let(T.unsafe(nil), String) + +# http://rubular.com/r/CvpbxkcTzy +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:39 +RuboCop::Cop::Lint::FormatParameterMismatch::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:41 +RuboCop::Cop::Lint::FormatParameterMismatch::MSG_INVALID = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:47 +RuboCop::Cop::Lint::FormatParameterMismatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:45 +RuboCop::Cop::Lint::FormatParameterMismatch::SHOVEL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/format_parameter_mismatch.rb:46 +RuboCop::Cop::Lint::FormatParameterMismatch::STRING_TYPES = T.let(T.unsafe(nil), Array) + +# Prefer using `Hash#compare_by_identity` rather than using `object_id` +# for hash keys. +# +# This cop looks for hashes being keyed by objects' `object_id`, using +# one of these methods: `key?`, `has_key?`, `fetch`, `[]` and `[]=`. +# +# @example +# # bad +# hash = {} +# hash[foo.object_id] = :bar +# hash.key?(baz.object_id) +# +# # good +# hash = {}.compare_by_identity +# hash[foo] = :bar +# hash.key?(baz) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/hash_compare_by_identity.rb:31 +class RuboCop::Cop::Lint::HashCompareByIdentity < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/hash_compare_by_identity.rb:37 + def id_as_hash_key?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/hash_compare_by_identity.rb:41 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/hash_compare_by_identity.rb:34 +RuboCop::Cop::Lint::HashCompareByIdentity::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/hash_compare_by_identity.rb:32 +RuboCop::Cop::Lint::HashCompareByIdentity::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the ordering of a method call where +# the receiver of the call is a HEREDOC. +# +# @example +# # bad +# +# <<-SQL +# bar +# SQL +# .strip_indent +# +# <<-SQL +# bar +# SQL +# .strip_indent +# .trim +# +# # good +# +# <<~SQL +# bar +# SQL +# +# <<~SQL.trim +# bar +# SQL +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:33 +class RuboCop::Cop::Lint::HeredocMethodCallPosition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:39 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:39 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:99 + def all_on_same_line?(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:52 + def autocorrect(corrector, node, heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:79 + def call_after_heredoc_range(heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:109 + def call_end_pos(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:118 + def call_line_range(node); end + + # Returns nil if no range can be safely repositioned. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:124 + def call_range_to_safely_reposition(node, heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:88 + def calls_on_multiple_lines?(node, _heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:84 + def correctly_positioned?(node, heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:113 + def heredoc_begin_line_range(heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:105 + def heredoc_end_pos(heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:75 + def heredoc_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:61 + def heredoc_node_descendent_receiver(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:69 + def send_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:148 + def trailing_comma?(call_source, call_line_source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/heredoc_method_call_position.rb:37 +RuboCop::Cop::Lint::HeredocMethodCallPosition::MSG = T.let(T.unsafe(nil), String) + +# Prefer `equal?` over `==` when comparing `object_id`. +# +# `Object#equal?` is provided to compare objects for identity, and in contrast +# `Object#==` is provided for the purpose of doing value comparison. +# +# @example +# # bad +# foo.object_id == bar.object_id +# +# # good +# foo.equal?(bar) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:19 +class RuboCop::Cop::Lint::IdentityComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:25 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:41 + def compare_between_object_id_by_double_equal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:45 + def object_id_method?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:22 +RuboCop::Cop::Lint::IdentityComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/identity_comparison.rb:23 +RuboCop::Cop::Lint::IdentityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for implicit string concatenation of string literals +# which are on the same line. +# +# @example +# +# # bad +# +# array = ['Item 1' 'Item 2'] +# @example +# +# # good +# +# array = ['Item 1Item 2'] +# array = ['Item 1' + 'Item 2'] +# array = [ +# 'Item 1' \ +# 'Item 2' +# ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:25 +class RuboCop::Cop::Lint::ImplicitStringConcatenation < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:33 + def on_dstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:83 + def display_str(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:50 + def each_bad_cons(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:65 + def ending_delimiter(str); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:91 + def str_content(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:75 + def string_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:79 + def string_literals?(node1, node2); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:28 +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_ARRAY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:30 +RuboCop::Cop::Lint::ImplicitStringConcatenation::FOR_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/implicit_string_concatenation.rb:26 +RuboCop::Cop::Lint::ImplicitStringConcatenation::MSG = T.let(T.unsafe(nil), String) + +# This cop checks for `IO.select` that is incompatible with Fiber Scheduler since Ruby 3.0. +# +# NOTE: When the method is successful the return value of `IO.select` is `[[IO]]`, +# and the return value of `io.wait_readable` and `io.wait_writable` are `self`. +# They are not autocorrected when assigning a return value because these types are different. +# It's up to user how to handle the return value. +# +# @example +# +# # bad +# IO.select([io], [], [], timeout) +# +# # good +# io.wait_readable(timeout) +# +# # bad +# IO.select([], [io], [], timeout) +# +# # good +# io.wait_writable(timeout) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:32 +class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:39 + def io_select(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:44 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:67 + def preferred_method(read, write, timeout); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:61 + def scheduler_compatible?(io1, io2); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:35 +RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/incompatible_io_select_with_fiber_scheduler.rb:36 +RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `private` or `protected` access modifiers which are +# applied to a singleton method. These access modifiers do not make +# singleton methods private/protected. `private_class_method` can be +# used for that. +# +# @example +# +# # bad +# +# class C +# private +# +# def self.method +# puts 'hi' +# end +# end +# @example +# +# # good +# +# class C +# def self.method +# puts 'hi' +# end +# +# private_class_method :method +# end +# @example +# +# # good +# +# class C +# class << self +# private +# +# def method +# puts 'hi' +# end +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:48 +class RuboCop::Cop::Lint::IneffectiveAccessModifier < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:59 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:59 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:55 + def private_class_methods(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:109 + def access_modifier?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:66 + def check_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:113 + def correct_visibility?(node, modifier, ignored_methods); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:78 + def format_message(modifier); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:91 + def ineffective_modifier(node, ignored_methods = T.unsafe(nil), modifier = T.unsafe(nil), &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:74 + def private_class_method_names(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:51 +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PRIVATE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:52 +RuboCop::Cop::Lint::IneffectiveAccessModifier::ALTERNATIVE_PROTECTED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ineffective_access_modifier.rb:49 +RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String) + +# Looks for error classes inheriting from `Exception`. +# It is configurable to suggest using either `StandardError` (default) or +# `RuntimeError` instead. +# +# @example EnforcedStyle: standard_error (default) +# # bad +# +# class C < Exception; end +# +# C = Class.new(Exception) +# +# # good +# +# class C < StandardError; end +# +# C = Class.new(StandardError) +# @example EnforcedStyle: runtime_error +# # bad +# +# class C < Exception; end +# +# C = Class.new(Exception) +# +# # good +# +# class C < RuntimeError; end +# +# C = Class.new(RuntimeError) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:40 +class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:53 + def class_new_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:59 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:69 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:86 + def exception_class?(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:82 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:90 + def preferred_base_class; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:44 +RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:45 +RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/inherit_exception.rb:50 +RuboCop::Cop::Lint::InheritException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for interpolation in a single quoted string. +# +# @example +# +# # bad +# +# foo = 'something with #{interpolation} inside' +# @example +# +# # good +# +# foo = "something with #{interpolation} inside" +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/interpolation_check.rb:24 +class RuboCop::Cop::Lint::InterpolationCheck < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/interpolation_check.rb:30 + def on_str(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/interpolation_check.rb:41 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/interpolation_check.rb:52 + def heredoc?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/interpolation_check.rb:27 +RuboCop::Cop::Lint::InterpolationCheck::MSG = T.let(T.unsafe(nil), String) + +# Checks uses of lambda without a literal block. +# It emulates the following warning in Ruby 3.0: +# +# % ruby -vwe 'lambda(&proc {})' +# ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] +# -e:1: warning: lambda without a literal block is deprecated; use the proc without +# lambda instead +# +# This way, proc object is never converted to lambda. +# Autocorrection replaces with compatible proc argument. +# +# @example +# +# # bad +# lambda(&proc { do_something }) +# lambda(&Proc.new { do_something }) +# +# # good +# proc { do_something } +# Proc.new { do_something } +# lambda { do_something } # If you use lambda. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/lambda_without_literal_block.rb:28 +class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/lambda_without_literal_block.rb:35 + def lambda_with_symbol_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/lambda_without_literal_block.rb:39 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/lambda_without_literal_block.rb:31 +RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/lambda_without_literal_block.rb:32 +RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for literals used as the conditions or as +# operands in and/or expressions serving as the conditions of +# if/while/until/case-when/case-in. +# +# NOTE: Literals in `case-in` condition where the match variable is used in +# `in` are accepted as a pattern matching. +# +# @example +# +# # bad +# if 20 +# do_something +# end +# +# # bad +# if some_var && true +# do_something +# end +# +# # good +# if some_var && some_condition +# do_something +# end +# +# # good +# # When using a boolean value for an infinite loop. +# while true +# break if condition +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:35 +class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:93 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:58 + def on_case(case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:73 + def on_case_match(case_match_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:40 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:87 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:51 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:51 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:44 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:44 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:108 + def basic_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:138 + def check_case(case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:99 + def check_for_literal(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:120 + def check_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:147 + def condition(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:130 + def handle_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:116 + def primitive_array?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:155 + def when_conditions_range(when_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_as_condition.rb:38 +RuboCop::Cop::Lint::LiteralAsCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for interpolated literals. +# +# @example +# +# # bad +# +# "result is #{10}" +# @example +# +# # good +# +# "result is 10" +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:19 +class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:28 + def on_interpolation(begin_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:62 + def autocorrected_value(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:97 + def autocorrected_value_for_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:82 + def autocorrected_value_for_string(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:90 + def autocorrected_value_for_symbol(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:113 + def ends_heredoc_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:121 + def in_array_percent_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:48 + def offending?(node); end + + # Does node print its own source when converted to a string? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:104 + def prints_as_self?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:109 + def space_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:56 + def special_keyword?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:26 +RuboCop::Cop::Lint::LiteralInInterpolation::COMPOSITE = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/literal_in_interpolation.rb:25 +RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of `begin...end while/until something`. +# +# @example +# +# # bad +# +# # using while +# begin +# do_something +# end while some_condition +# @example +# +# # bad +# +# # using until +# begin +# do_something +# end until some_condition +# @example +# +# # good +# +# # while replacement +# loop do +# do_something +# break unless some_condition +# end +# @example +# +# # good +# +# # until replacement +# loop do +# do_something +# break if some_condition +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:50 +class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:59 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:55 + def on_while_post(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:79 + def build_break_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:75 + def keyword_and_condition_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:65 + def register_offense(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/loop.rb:53 +RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String) + +# cop disables on wide ranges of code, that latter contributors to +# a file wouldn't be aware of. +# +# @example +# # Lint/MissingCopEnableDirective: +# # MaximumRangeSize: .inf +# +# # good +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # rubocop:enable Layout/SpaceAroundOperators +# # y = 1 +# # EOF +# +# # bad +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # EOF +# @example +# # Lint/MissingCopEnableDirective: +# # MaximumRangeSize: 2 +# +# # good +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# # With the previous, there are 2 lines on which cop is disabled. +# # rubocop:enable Layout/SpaceAroundOperators +# +# # bad +# # rubocop:disable Layout/SpaceAroundOperators +# x= 0 +# x += 1 +# # Including this, that's 3 lines on which the cop is disabled. +# # rubocop:enable Layout/SpaceAroundOperators +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:45 +class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:51 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:89 + def department_enabled?(cop, comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:66 + def each_missing_enable; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:72 + def max_range; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:76 + def message(cop, comment, type = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:48 +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_cop_enable_directive.rb:49 +RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), String) + +# Checks for the presence of constructors and lifecycle callbacks +# without calls to `super`. +# +# This cop does not consider `method_missing` (and `respond_to_missing?`) +# because in some cases it makes sense to overtake what is considered a +# missing method. In other cases, the theoretical ideal handling could be +# challenging or verbose for no actual gain. +# +# @example +# # bad +# class Employee < Person +# def initialize(name, salary) +# @salary = salary +# end +# end +# +# # good +# class Employee < Person +# def initialize(name, salary) +# super(name) +# @salary = salary +# end +# end +# +# # bad +# class Parent +# def self.inherited(base) +# do_something +# end +# end +# +# # good +# class Parent +# def self.inherited(base) +# super +# do_something +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:45 +class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:58 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:68 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:80 + def callback_method_def?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:86 + def contains_super?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:90 + def inside_class_with_stateful_parent?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:76 + def offender?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:95 + def stateless_class?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:56 +RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:47 +RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:51 +RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:46 +RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:52 +RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/missing_super.rb:49 +RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array) + +# Do not mix named captures and numbered captures in a Regexp literal +# because numbered capture is ignored if they're mixed. +# Replace numbered captures with non-capturing groupings or +# named captures. +# +# # bad +# /(?<foo>FOO)(BAR)/ +# +# # good +# /(?<foo>FOO)(?<bar>BAR)/ +# +# # good +# /(?<foo>FOO)(?:BAR)/ +# +# # good +# /(FOO)(BAR)/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb:23 +class RuboCop::Cop::Lint::MixedRegexpCaptureTypes < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb:26 + def on_regexp(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb:24 +RuboCop::Cop::Lint::MixedRegexpCaptureTypes::MSG = T.let(T.unsafe(nil), String) + +# In math and Python, we can use `x < y < z` style comparison to compare +# multiple value. However, we can't use the comparison in Ruby. However, +# the comparison is not syntax error. This cop checks the bad usage of +# comparison operators. +# +# @example +# +# # bad +# x < y < z +# 10 <= x <= 20 +# +# # good +# x < y && y < z +# 10 <= x && x <= 20 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:20 +class RuboCop::Cop::Lint::MultipleComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:29 + def multiple_compare?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:33 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:24 +RuboCop::Cop::Lint::MultipleComparison::COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:23 +RuboCop::Cop::Lint::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:26 +RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/multiple_comparison.rb:25 +RuboCop::Cop::Lint::MultipleComparison::SET_OPERATION_OPERATORS = T.let(T.unsafe(nil), Array) + +# Checks for nested method definitions. +# +# @example +# +# # bad +# +# # `bar` definition actually produces methods in the same scope +# # as the outer `foo` method. Furthermore, the `bar` method +# # will be redefined every time `foo` is invoked. +# def foo +# def bar +# end +# end +# @example +# +# # good +# +# def foo +# bar = -> { puts 'hello' } +# bar.call +# end +# @example +# +# # good +# +# def foo +# self.class.class_eval do +# def bar +# end +# end +# end +# +# def foo +# self.class.module_exec do +# def bar +# end +# end +# end +# @example +# +# # good +# +# def foo +# class << self +# def bar +# end +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:57 +class RuboCop::Cop::Lint::NestedMethodDefinition < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:94 + def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:84 + def eval_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:89 + def exec_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:60 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:60 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:78 + def scoping_method_call?(child); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_method_definition.rb:58 +RuboCop::Cop::Lint::NestedMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for nested percent literals. +# +# @example +# +# # bad +# +# # The percent literal for nested_attributes is parsed as four tokens, +# # yielding the array [:name, :content, :"%i[incorrectly", :"nested]"]. +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: %i[name content %i[incorrectly nested]] +# } +# +# # good +# +# # Neither is incompatible with the bad case, but probably the intended code. +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: [:name, :content, %i[incorrectly nested]] +# } +# +# attributes = { +# valid_attributes: %i[name content], +# nested_attributes: [:name, :content, [:incorrectly, :nested]] +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:32 +class RuboCop::Cop::Lint::NestedPercentLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:44 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:48 + def on_percent_literal(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:54 + def contains_percent_literals?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:35 +RuboCop::Cop::Lint::NestedPercentLiteral::MSG = T.let(T.unsafe(nil), String) + +# The array of regular expressions representing percent literals that, +# if found within a percent literal expression, will cause a +# NestedPercentLiteral violation to be emitted. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:41 +RuboCop::Cop::Lint::NestedPercentLiteral::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/nested_percent_literal.rb:42 +RuboCop::Cop::Lint::NestedPercentLiteral::REGEXES = T.let(T.unsafe(nil), Array) + +# Don't omit the accumulator when calling `next` in a `reduce` block. +# +# @example +# +# # bad +# +# result = (1..4).reduce(0) do |acc, i| +# next if i.odd? +# acc + i +# end +# @example +# +# # good +# +# result = (1..4).reduce(0) do |acc, i| +# next acc if i.odd? +# acc + i +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:25 +class RuboCop::Cop::Lint::NextWithoutAccumulator < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:28 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:51 + def on_block_body_of_reduce(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:38 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:56 + def on_numblock_body_of_reduce(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:60 + def parent_block_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:64 + def parent_numblock_node(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/next_without_accumulator.rb:26 +RuboCop::Cop::Lint::NextWithoutAccumulator::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of a `return` inside a `begin..end` block +# in assignment contexts. +# In this situation, the `return` will result in an exit from the current +# method, possibly leading to unexpected behavior. +# +# @example +# +# # bad +# +# @some_variable ||= begin +# return some_value if some_condition_is_met +# +# do_something +# end +# @example +# +# # good +# +# @some_variable ||= begin +# if some_condition_is_met +# some_value +# else +# do_something +# end +# end +# +# # good +# +# some_variable = if some_condition_is_met +# return if another_condition_is_met +# +# some_value +# else +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb:43 +class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb:46 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb:46 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb:46 + def on_or_asgn(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/no_return_in_begin_end_blocks.rb:44 +RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-atomic file operation. +# And then replace it with a nearly equivalent and atomic method. +# +# These can cause problems that are difficult to reproduce, +# especially in cases of frequent file operations in parallel, +# such as test runs with parallel_rspec. +# +# For examples: creating a directory if there is none, has the following problems +# +# An exception occurs when the directory didn't exist at the time of `exist?`, +# but someone else created it before `mkdir` was executed. +# +# Subsequent processes are executed without the directory that should be there +# when the directory existed at the time of `exist?`, +# but someone else deleted it shortly afterwards. +# +# @example +# # bad - race condition with another process may result in an error in `mkdir` +# unless Dir.exist?(path) +# FileUtils.mkdir(path) +# end +# +# # good - atomic and idempotent creation +# FileUtils.mkdir_p(path) +# +# # bad - race condition with another process may result in an error in `remove` +# if File.exist?(path) +# FileUtils.remove(path) +# end +# +# # good - atomic and idempotent removal +# FileUtils.rm_f(path) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:44 +class RuboCop::Cop::Lint::NonAtomicFileOperation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:76 + def explicit_not_force?(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:71 + def force?(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:80 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:66 + def receiver_and_method_name(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:61 + def send_exist_node(param0); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:97 + def allowable_use_with_if?(if_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:120 + def autocorrect(corrector, node, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:126 + def autocorrect_replace_method(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:143 + def force_method?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:151 + def force_method_name?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:147 + def force_option?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:91 + def if_node_child?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:111 + def message_change_force_method(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:115 + def message_remove_file_exist_check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:101 + def register_offense(node, exist_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:133 + def replacement_method(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:52 +RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_FORCE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:53 +RuboCop::Cop::Lint::NonAtomicFileOperation::MAKE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:51 +RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_CHANGE_FORCE_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:49 +RuboCop::Cop::Lint::NonAtomicFileOperation::MSG_REMOVE_FILE_EXIST_CHECK = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:54 +RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_FORCE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:55 +RuboCop::Cop::Lint::NonAtomicFileOperation::REMOVE_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_atomic_file_operation.rb:57 +RuboCop::Cop::Lint::NonAtomicFileOperation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# `Dir[...]` and `Dir.glob(...)` do not make any guarantees about +# the order in which files are returned. The final order is +# determined by the operating system and file system. +# This means that using them in cases where the order matters, +# such as requiring files, can lead to intermittent failures +# that are hard to debug. To ensure this doesn't happen, +# always sort the list. +# +# `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0. +# So all bad cases are acceptable when Ruby 3.0 or higher are used. +# +# NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher. +# +# @example +# +# # bad +# Dir["./lib/**/*.rb"].each do |file| +# require file +# end +# +# # good +# Dir["./lib/**/*.rb"].sort.each do |file| +# require file +# end +# +# # bad +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file| +# require file +# end +# +# # good +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file| +# require file +# end +# +# # bad +# Dir['./lib/**/*.rb'].each(&method(:require)) +# +# # good +# Dir['./lib/**/*.rb'].sort.each(&method(:require)) +# +# # bad +# Dir.glob(Rails.root.join('test', '*.rb'), &method(:require)) +# +# # good +# Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require)) +# +# # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher. +# Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require)) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:60 +class RuboCop::Cop::Lint::NonDeterministicRequireOrder < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:174 + def loop_variable(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:157 + def method_require?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:65 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:89 + def on_block_pass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:77 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:147 + def unsorted_dir_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:152 + def unsorted_dir_each?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:168 + def unsorted_dir_each_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:162 + def unsorted_dir_glob_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:179 + def var_is_required?(param0, param1); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:107 + def correct_block(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:117 + def correct_block_pass(corrector, node); end + + # Returns range of last argument including comma and whitespace. + # + # @return [Parser::Source::Range] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:132 + def last_arg_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:138 + def unsorted_dir_loop?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:142 + def unsorted_dir_pass?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_deterministic_require_order.rb:63 +RuboCop::Cop::Lint::NonDeterministicRequireOrder::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-local exits from iterators without a return +# value. It registers an offense under these conditions: +# +# * No value is returned, +# * the block is preceded by a method chain, +# * the block has arguments, +# * the method which receives the block is not `define_method` +# or `define_singleton_method`, +# * the return is not contained in an inner scope, e.g. a lambda or a +# method definition. +# +# @example +# +# class ItemApi +# rescue_from ValidationError do |e| # non-iteration block with arg +# return { message: 'validation error' } unless e.errors # allowed +# error_array = e.errors.map do |error| # block with method chain +# return if error.suppress? # warned +# return "#{error.param}: invalid" unless error.message # allowed +# "#{error.param}: #{error.message}" +# end +# { message: 'validation error', errors: error_array } +# end +# +# def update_items +# transaction do # block without arguments +# return unless update_necessary? # allowed +# find_each do |item| # block without method chain +# return if item.stock == 0 # false-negative... +# item.update!(foobar: true) +# end +# end +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:41 +class RuboCop::Cop::Lint::NonLocalExitFromIterator < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:77 + def chained_send?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:80 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:46 + def on_return(return_node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:72 + def return_value?(return_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:68 + def scoped_node?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb:42 +RuboCop::Cop::Lint::NonLocalExitFromIterator::MSG = T.let(T.unsafe(nil), String) + +# Warns the usage of unsafe number conversions. Unsafe +# number conversion can cause unexpected error if auto type conversion +# fails. Cop prefer parsing with number class instead. +# +# Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError` +# if given input that is not numeric (eg. an empty string), whereas +# `to_i`, etc. will try to convert regardless of input (`''.to_i => 0`). +# As such, this cop is disabled by default because it's not necessarily +# always correct to raise if a value is not numeric. +# +# NOTE: Some values cannot be converted properly using one of the `Kernel` +# method (for instance, `Time` and `DateTime` values are allowed by this +# cop by default). Similarly, Rails' duration methods do not work well +# with `Integer()` and can be allowed with `AllowedMethods`. By default, +# there are no methods to allowed. +# +# @example +# +# # bad +# +# '10'.to_i +# '10.2'.to_f +# '10'.to_c +# '1/3'.to_r +# ['1', '2', '3'].map(&:to_i) +# foo.try(:to_f) +# bar.send(:to_c) +# +# # good +# +# Integer('10', 10) +# Float('10.2') +# Complex('10') +# Rational('1/3') +# ['1', '2', '3'].map { |i| Integer(i, 10) } +# foo.try { |i| Float(i) } +# bar.send { |i| Complex(i) } +# @example AllowedMethods: [] (default) +# +# # bad +# 10.minutes.to_i +# @example AllowedMethods: [minutes] +# +# # good +# 10.minutes.to_i +# @example AllowedPatterns: [] (default) +# +# # bad +# 10.minutes.to_i +# @example AllowedPatterns: [/min*/] +# +# # good +# 10.minutes.to_i +# @example IgnoredClasses: [Time, DateTime] (default) +# +# # good +# Time.now.to_datetime.to_i +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:73 +class RuboCop::Cop::Lint::NumberConversion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:102 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:92 + def to_method(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:97 + def to_method_symbol(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:155 + def allow_receiver?(receiver); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:167 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:177 + def conversion_method?(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:141 + def correct_method(node, receiver); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:145 + def correct_sym_method(to_method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:124 + def handle_as_symbol(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:109 + def handle_conversion_method(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:185 + def ignored_class?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:181 + def ignored_classes; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:150 + def remove_parentheses(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:171 + def top_receiver(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:88 +RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:78 +RuboCop::Cop::Lint::NumberConversion::CONVERSION_METHOD_CLASS_MAPPING = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:89 +RuboCop::Cop::Lint::NumberConversion::METHODS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/number_conversion.rb:84 +RuboCop::Cop::Lint::NumberConversion::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of numbered parameter assignment. +# It emulates the following warning in Ruby 2.7: +# +# % ruby -ve '_1 = :value' +# ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19] +# -e:1: warning: `_1' is reserved for numbered parameter; consider another name +# +# Assigning to a numbered parameter (from `_1` to `_9`) causes an error in Ruby 3.0. +# +# % ruby -ve '_1 = :value' +# ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19] +# -e:1: _1 is reserved for numbered parameter +# +# NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10` +# as well to prevent confusion. +# +# @example +# +# # bad +# _1 = :value +# +# # good +# non_numbered_parameter_name = :value +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/numbered_parameter_assignment.rb:30 +class RuboCop::Cop::Lint::NumberedParameterAssignment < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/numbered_parameter_assignment.rb:35 + def on_lvasgn(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/numbered_parameter_assignment.rb:32 +RuboCop::Cop::Lint::NumberedParameterAssignment::LVAR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/numbered_parameter_assignment.rb:33 +RuboCop::Cop::Lint::NumberedParameterAssignment::NUMBERED_PARAMETER_RANGE = T.let(T.unsafe(nil), Range) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/numbered_parameter_assignment.rb:31 +RuboCop::Cop::Lint::NumberedParameterAssignment::NUM_PARAM_MSG = T.let(T.unsafe(nil), String) + +# Checks for unintended or-assignment to a constant. +# +# Constants should always be assigned in the same location. And its value +# should always be the same. If constants are assigned in multiple +# locations, the result may vary depending on the order of `require`. +# +# @example +# +# # bad +# CONST ||= 1 +# +# # good +# CONST = 1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/or_assignment_to_constant.rb:24 +class RuboCop::Cop::Lint::OrAssignmentToConstant < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/or_assignment_to_constant.rb:29 + def on_or_asgn(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/or_assignment_to_constant.rb:27 +RuboCop::Cop::Lint::OrAssignmentToConstant::MSG = T.let(T.unsafe(nil), String) + +# Checks the proper ordering of magic comments and whether +# a magic comment is not placed before a shebang. +# +# @example +# # bad +# +# # frozen_string_literal: true +# # encoding: ascii +# p [''.frozen?, ''.encoding] #=> [true, #<Encoding:UTF-8>] +# +# # good +# +# # encoding: ascii +# # frozen_string_literal: true +# p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>] +# +# # good +# +# #!/usr/bin/env ruby +# # encoding: ascii +# # frozen_string_literal: true +# p [''.frozen?, ''.encoding] #=> [true, #<Encoding:US-ASCII>] +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:30 +class RuboCop::Cop::Lint::OrderedMagicComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:36 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:53 + def autocorrect(corrector, encoding_line, frozen_string_literal_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:61 + def magic_comment_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:77 + def magic_comments; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/ordered_magic_comments.rb:34 +RuboCop::Cop::Lint::OrderedMagicComments::MSG = T.let(T.unsafe(nil), String) + +# This cops looks for references of Regexp captures that are out of range +# and thus always returns nil. +# +# @example +# +# /(foo)bar/ =~ 'foobar' +# +# # bad - always returns nil +# +# puts $2 # => nil +# +# # good +# +# puts $1 # => foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:38 +class RuboCop::Cop::Lint::OutOfRangeRegexpRef < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:55 + def after_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:51 + def on_match_with_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:47 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:71 + def on_nth_ref(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:65 + def on_when(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:87 + def check_regexp(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:107 + def nth_ref_receiver?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:98 + def regexp_first_argument?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:103 + def regexp_receiver?(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:39 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:42 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_ARGUMENT_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:44 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_CAPTURE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:41 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::REGEXP_RECEIVER_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:45 +RuboCop::Cop::Lint::OutOfRangeRegexpRef::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# Checks for space between the name of a called method and a left +# parenthesis. +# +# @example +# +# # bad +# do_something (foo) +# +# # good +# do_something(foo) +# do_something (2 + 3) * 4 +# do_something (foo * bar).baz +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:18 +class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:24 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:24 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:56 + def chained_calls?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:52 + def first_argument_starts_with_left_parenthesis?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:81 + def space_range(expr, space_length); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:65 + def spaces_before_left_parenthesis(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:61 + def ternary_expression?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:39 + def valid_context?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:48 + def valid_first_argument?(first_arg); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb:22 +RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::MSG = T.let(T.unsafe(nil), String) + +# Checks for quotes and commas in %w, e.g. `%w('foo', "bar")` +# +# It is more likely that the additional characters are unintended (for +# example, mistranslating an array of literals to percent string notation) +# rather than meant to be part of the resulting strings. +# +# @example +# +# # bad +# +# %w('foo', "bar") +# @example +# +# # good +# +# %w(foo bar) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:33 +class RuboCop::Cop::Lint::PercentStringArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:44 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:48 + def on_percent_literal(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:65 + def contains_quotes_or_commas?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:38 +RuboCop::Cop::Lint::PercentStringArray::LEADING_QUOTE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:41 +RuboCop::Cop::Lint::PercentStringArray::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:37 +RuboCop::Cop::Lint::PercentStringArray::QUOTES_AND_COMMAS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_string_array.rb:39 +RuboCop::Cop::Lint::PercentStringArray::TRAILING_QUOTE = T.let(T.unsafe(nil), Regexp) + +# Checks for colons and commas in %i, e.g. `%i(:foo, :bar)` +# +# It is more likely that the additional characters are unintended (for +# example, mistranslating an array of literals to percent string notation) +# rather than meant to be part of the resulting symbols. +# +# @example +# +# # bad +# +# %i(:foo, :bar) +# @example +# +# # good +# +# %i(foo bar) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:23 +class RuboCop::Cop::Lint::PercentSymbolArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:30 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:34 + def on_percent_literal(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:42 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:52 + def contains_colons_or_commas?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:62 + def non_alphanumeric_literal?(literal); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/percent_symbol_array.rb:27 +RuboCop::Cop::Lint::PercentSymbolArray::MSG = T.let(T.unsafe(nil), String) + +# Checks for `raise` or `fail` statements which are +# raising `Exception` class. +# +# You can specify a module name that will be an implicit namespace +# using `AllowedImplicitNamespaces` option. The cop cause a false positive +# for namespaced `Exception` when a namespace is omitted. This option can +# prevent the false positive by specifying a namespace to be omitted for +# `Exception`. Alternatively, make `Exception` a fully qualified class +# name with an explicit namespace. +# +# @example +# # bad +# raise Exception, 'Error message here' +# +# # good +# raise StandardError, 'Error message here' +# @example AllowedImplicitNamespaces: ['Gem'] +# # good +# module Gem +# def self.foo +# raise Exception # This exception means `Gem::Exception`. +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:34 +class RuboCop::Cop::Lint::RaiseException < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:41 + def exception?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:46 + def exception_new_with_message?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:51 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:85 + def allow_implicit_namespaces; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:57 + def check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:73 + def implicit_namespace?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:37 +RuboCop::Cop::Lint::RaiseException::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/raise_exception.rb:38 +RuboCop::Cop::Lint::RaiseException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `rand(1)` calls. +# Such calls always return `0`. +# +# @example +# +# # bad +# +# rand 1 +# Kernel.rand(-1) +# rand 1.0 +# rand(-1.0) +# @example +# +# # good +# +# 0 # just use 0 instead +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:23 +class RuboCop::Cop::Lint::RandOne < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:32 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:28 + def rand_one?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:40 + def message(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:24 +RuboCop::Cop::Lint::RandOne::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rand_one.rb:25 +RuboCop::Cop::Lint::RandOne::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# removed without causing any offenses to be reported. It's implemented +# as a cop in that it inherits from the Cop base class and calls +# add_offense. The unusual part of its implementation is that it doesn't +# have any on_* methods or an investigate method. This means that it +# doesn't take part in the investigation phase when the other cops do +# their work. Instead, it waits until it's called in a later stage of the +# execution. The reason it can't be implemented as a normal cop is that +# it depends on the results of all other cops to do its work. +# +# @example +# # bad +# # rubocop:disable Layout/LineLength +# x += 1 +# # rubocop:enable Layout/LineLength +# +# # good +# x += 1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:28 +class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [RedundantCopDisableDirective] a new instance of RedundantCopDisableDirective + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:37 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil), offenses = T.unsafe(nil)); end + + # Returns the value of attribute offenses_to_check. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:35 + def offenses_to_check; end + + # Sets the attribute offenses_to_check + # + # @param value the value to set the attribute offenses_to_check to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:35 + def offenses_to_check=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:42 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:283 + def add_department_marker(department); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:206 + def add_offense_for_entire_comment(comment, cops); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:216 + def add_offense_for_some_cops(comment, cops); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:196 + def add_offenses(redundant_cops); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:266 + def all_cop_names; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:177 + def all_disabled?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:69 + def comment_range_with_surrounding_space(directive_comment_range, line_comment_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:57 + def cop_disabled_line_ranges; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:230 + def cop_range(comment, cop); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:187 + def department_disabled?(cop, comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:275 + def department_marker?(department); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:253 + def describe(cop); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:192 + def directive_count(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:92 + def directive_range_in_list(range, ranges); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:61 + def disabled_ranges; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:130 + def each_already_disabled(cop, line_ranges); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:113 + def each_line_range(cop, line_ranges); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:106 + def each_redundant_disable(&block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:270 + def ends_its_line?(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:153 + def find_redundant_all(range, next_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:148 + def find_redundant_cop(cop, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:163 + def find_redundant_department(cop, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:169 + def followed_ranges?(range, next_range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:181 + def ignore_offense?(line_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:237 + def matching_range(haystack, needle); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:262 + def message(cop_names); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:65 + def previous_line_blank?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:173 + def range_with_offense?(range, offenses = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:279 + def remove_department_marker(department); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:245 + def trailing_range?(ranges, range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:32 +RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:33 +RuboCop::Cop::Lint::RedundantCopDisableDirective::DEPARTMENT_MARKER = T.let(T.unsafe(nil), String) + +# removed. +# +# that cop checks whether any cop was actually enabled. +# +# @example +# # bad +# foo = 1 +# # rubocop:enable Layout/LineLength +# +# # good +# foo = 1 +# @example +# # bad +# # rubocop:disable Style/StringLiterals +# foo = "1" +# # rubocop:enable Style/StringLiterals +# baz +# # rubocop:enable all +# +# # good +# # rubocop:disable Style/StringLiterals +# foo = "1" +# # rubocop:enable all +# baz +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:37 +class RuboCop::Cop::Lint::RedundantCopEnableDirective < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:44 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:120 + def all_or_name(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:76 + def comment_start(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:80 + def cop_name_indention(comment, name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:124 + def department?(directive, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:71 + def range_of_offense(comment, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:95 + def range_to_remove(begin_pos, end_pos, comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:84 + def range_with_comma(comment, name); end + + # If the list of cops is comma-separated, but without a empty space after the comma, + # we should **not** remove the prepending empty space, thus begin_pos += 1 + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:114 + def range_with_comma_after(comment, start, begin_pos, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:108 + def range_with_comma_before(start, begin_pos, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:53 + def register_offense(comment, cop_names); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb:42 +RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG = T.let(T.unsafe(nil), String) + +# Sort globbed results by default in Ruby 3.0. +# This cop checks for redundant `sort` method to `Dir.glob` and `Dir[]`. +# +# @example +# +# # bad +# Dir.glob('./lib/**/*.rb').sort.each do |file| +# end +# +# Dir['./lib/**/*.rb'].sort.each do |file| +# end +# +# # good +# Dir.glob('./lib/**/*.rb').each do |file| +# end +# +# Dir['./lib/**/*.rb'].each do |file| +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:30 +class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:40 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:38 +RuboCop::Cop::Lint::RedundantDirGlobSort::GLOB_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:36 +RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:37 +RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for unnecessary `require` statement. +# +# The following features are unnecessary `require` statement because +# they are already loaded. +# +# ruby -ve 'p $LOADED_FEATURES.reject { |feature| %r|/| =~ feature }' +# ruby 2.2.8p477 (2017-09-14 revision 59906) [x86_64-darwin13] +# ["enumerator.so", "rational.so", "complex.so", "thread.rb"] +# +# This cop targets Ruby 2.2 or higher containing these 4 features. +# +# @example +# # bad +# require 'unloaded_feature' +# require 'thread' +# +# # good +# require 'unloaded_feature' +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_require_statement.rb:24 +class RuboCop::Cop::Lint::RedundantRequireStatement < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_require_statement.rb:40 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_require_statement.rb:35 + def unnecessary_require_statement?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_require_statement.rb:31 +RuboCop::Cop::Lint::RedundantRequireStatement::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_require_statement.rb:32 +RuboCop::Cop::Lint::RedundantRequireStatement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for redundant safe navigation calls. +# `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`, and `equal?` methods +# are checked by default. These are customizable with `AllowedMethods` option. +# +# The `AllowedMethods` option specifies nil-safe methods, +# in other words, it is a method that is allowed to skip safe navigation. +# Note that the `AllowedMethod` option is not an option that specifies methods +# for which to suppress (allow) this cop's check. +# +# In the example below, the safe navigation operator (`&.`) is unnecessary +# because `NilClass` has methods like `respond_to?` and `is_a?`. +# +# @example +# # bad +# do_something if attrs&.respond_to?(:[]) +# +# # good +# do_something if attrs.respond_to?(:[]) +# +# # bad +# while node&.is_a?(BeginNode) +# node = node.parent +# end +# +# # good +# while node.is_a?(BeginNode) +# node = node.parent +# end +# +# # good - without `&.` this will always return `true` +# foo&.respond_to?(:to_a) +# @example AllowedMethods: [nil_safe_method] +# # bad +# do_something if attrs&.nil_safe_method(:[]) +# +# # good +# do_something if attrs.nil_safe_method(:[]) +# do_something if attrs&.not_nil_safe_method(:[]) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:51 +class RuboCop::Cop::Lint::RedundantSafeNavigation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:65 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:61 + def respond_to_nil_specific_method?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:75 + def check?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:85 + def condition?(parent, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:56 +RuboCop::Cop::Lint::RedundantSafeNavigation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_safe_navigation.rb:58 +RuboCop::Cop::Lint::RedundantSafeNavigation::NIL_SPECIFIC_METHODS = T.let(T.unsafe(nil), Set) + +# Checks for unneeded usages of splat expansion +# +# @example +# +# # bad +# a = *[1, 2, 3] +# a = *'a' +# a = *1 +# ['a', 'b', *%w(c d e), 'f', 'g'] +# +# # good +# c = [1, 2, 3] +# a = *c +# a, b = *c +# a, *b = *c +# a = *1..10 +# a = ['a'] +# ['a', 'b', 'c', 'd', 'e', 'f', 'g'] +# +# # bad +# do_something(*['foo', 'bar', 'baz']) +# +# # good +# do_something('foo', 'bar', 'baz') +# +# # bad +# begin +# foo +# rescue *[StandardError, ApplicationError] +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, ApplicationError +# bar +# end +# +# # bad +# case foo +# when *[1, 2, 3] +# bar +# else +# baz +# end +# +# # good +# case foo +# when 1, 2, 3 +# bar +# else +# baz +# end +# @example AllowPercentLiteralArrayArgument: true (default) +# +# # good +# do_something(*%w[foo bar baz]) +# @example AllowPercentLiteralArrayArgument: false +# +# # bad +# do_something(*%w[foo bar baz]) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:71 +class RuboCop::Cop::Lint::RedundantSplatExpansion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:83 + def array_new?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:91 + def literal_expansion(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:95 + def on_splat(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:203 + def allow_percent_literal_array_argument?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:131 + def array_new_inside_array_literal?(array_new_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:155 + def array_splat?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:112 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:159 + def method_argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:163 + def part_of_an_array?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:170 + def redundant_brackets?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:118 + def redundant_splat_expansion(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:178 + def remove_brackets(array); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:138 + def replacement_range_and_content(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:196 + def use_percent_literal_array_argument?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:75 +RuboCop::Cop::Lint::RedundantSplatExpansion::ARRAY_PARAM_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:80 +RuboCop::Cop::Lint::RedundantSplatExpansion::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:74 +RuboCop::Cop::Lint::RedundantSplatExpansion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:79 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_I = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:77 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_CAPITAL_W = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:78 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_I = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_splat_expansion.rb:76 +RuboCop::Cop::Lint::RedundantSplatExpansion::PERCENT_W = T.let(T.unsafe(nil), String) + +# Checks for string conversion in string interpolation, +# which is redundant. +# +# @example +# +# # bad +# +# "result is #{something.to_s}" +# @example +# +# # good +# +# "result is #{something}" +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_string_coercion.rb:20 +class RuboCop::Cop::Lint::RedundantStringCoercion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_string_coercion.rb:30 + def on_interpolation(begin_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_string_coercion.rb:28 + def to_s_without_args?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_string_coercion.rb:24 +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_DEFAULT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_string_coercion.rb:25 +RuboCop::Cop::Lint::RedundantStringCoercion::MSG_SELF = T.let(T.unsafe(nil), String) + +# Checks for redundant `with_index`. +# +# @example +# # bad +# ary.each_with_index do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# # bad +# ary.each.with_index do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:29 +class RuboCop::Cop::Lint::RedundantWithIndex < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:36 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:36 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:56 + def redundant_with_index?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:66 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:74 + def with_index_range(send); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:33 +RuboCop::Cop::Lint::RedundantWithIndex::MSG_EACH_WITH_INDEX = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_index.rb:34 +RuboCop::Cop::Lint::RedundantWithIndex::MSG_WITH_INDEX = T.let(T.unsafe(nil), String) + +# Checks for redundant `with_object`. +# +# @example +# # bad +# ary.each_with_object([]) do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# # bad +# ary.each.with_object([]) do |v| +# v +# end +# +# # good +# ary.each do |v| +# v +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:29 +class RuboCop::Cop::Lint::RedundantWithObject < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:36 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:36 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:56 + def redundant_with_object?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:65 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:73 + def with_object_range(send); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:33 +RuboCop::Cop::Lint::RedundantWithObject::MSG_EACH_WITH_OBJECT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/redundant_with_object.rb:34 +RuboCop::Cop::Lint::RedundantWithObject::MSG_WITH_OBJECT = T.let(T.unsafe(nil), String) + +# Checks if `include` or `prepend` is called in `refine` block. +# These methods are deprecated and should be replaced with `Refinement#import_methods`. +# +# It emulates deprecation warnings in Ruby 3.1. +# +# @example +# +# # bad +# refine Foo do +# include Bar +# end +# +# # bad +# refine Foo do +# prepend Bar +# end +# +# # good +# refine Foo do +# import_methods Bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/refinement_import_methods.rb:34 +class RuboCop::Cop::Lint::RefinementImportMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/refinement_import_methods.rb:42 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/refinement_import_methods.rb:37 +RuboCop::Cop::Lint::RefinementImportMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/refinement_import_methods.rb:38 +RuboCop::Cop::Lint::RefinementImportMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for regexp literals used as `match-current-line`. +# If a regexp literal is in condition, the regexp matches `$_` implicitly. +# +# @example +# # bad +# if /foo/ +# do_something +# end +# +# # good +# if /foo/ =~ $_ +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/regexp_as_condition.rb:19 +class RuboCop::Cop::Lint::RegexpAsCondition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/regexp_as_condition.rb:25 + def on_match_current_line(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/regexp_as_condition.rb:22 +RuboCop::Cop::Lint::RegexpAsCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for expressions where there is a call to a predicate +# method with at least one argument, where no parentheses are used around +# the parameter list, and a boolean operator, && or ||, is used in the +# last argument. +# +# The idea behind warning for these constructs is that the user might +# be under the impression that the return value from the method call is +# an operand of &&/||. +# +# @example +# +# # bad +# +# if day.is? :tuesday && month == :jan +# # ... +# end +# @example +# +# # good +# +# if day.is?(:tuesday) && month == :jan +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:30 +class RuboCop::Cop::Lint::RequireParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:35 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:35 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:56 + def check_predicate(predicate, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:48 + def check_ternary(ternary, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_parentheses.rb:33 +RuboCop::Cop::Lint::RequireParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks that a range literal is enclosed in parentheses when the end of the range is +# at a line break. +# +# NOTE: The following is maybe intended for `(42..)`. But, compatible is `42..do_something`. +# So, this cop does not provide autocorrection because it is left to user. +# +# [source,ruby] +# ---- +# case condition +# when 42.. +# do_something +# end +# ---- +# +# @example +# +# # bad - Represents `(1..42)`, not endless range. +# 1.. +# 42 +# +# # good - It's incompatible, but your intentions when using endless range may be: +# (1..) +# 42 +# +# # good +# 1..42 +# +# # good +# (1..42) +# +# # good +# (1.. +# 42) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_range_parentheses.rb:40 +class RuboCop::Cop::Lint::RequireRangeParentheses < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_range_parentheses.rb:43 + def on_erange(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_range_parentheses.rb:43 + def on_irange(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_range_parentheses.rb:41 +RuboCop::Cop::Lint::RequireRangeParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses a file requiring itself with `require_relative`. +# +# @example +# +# # bad +# +# # foo.rb +# require_relative 'foo' +# require_relative 'bar' +# +# # good +# +# # foo.rb +# require_relative 'bar' +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:21 +class RuboCop::Cop::Lint::RequireRelativeSelfPath < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:28 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:44 + def remove_ext(file_path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:40 + def same_file?(file_path, required_feature); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:25 +RuboCop::Cop::Lint::RequireRelativeSelfPath::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/require_relative_self_path.rb:26 +RuboCop::Cop::Lint::RequireRelativeSelfPath::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `rescue` blocks targeting the Exception class. +# +# @example +# +# # bad +# +# begin +# do_something +# rescue Exception +# handle_exception +# end +# @example +# +# # good +# +# begin +# do_something +# rescue ArgumentError +# handle_exception +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_exception.rb:27 +class RuboCop::Cop::Lint::RescueException < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_exception.rb:30 + def on_resbody(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_exception.rb:39 + def targets_exception?(rescue_arg_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_exception.rb:28 +RuboCop::Cop::Lint::RescueException::MSG = T.let(T.unsafe(nil), String) + +# Check for arguments to `rescue` that will result in a `TypeError` +# if an exception is raised. +# +# @example +# # bad +# begin +# bar +# rescue nil +# baz +# end +# +# # bad +# def foo +# bar +# rescue 1, 'a', "#{b}", 0.0, [], {} +# baz +# end +# +# # good +# begin +# bar +# rescue +# baz +# end +# +# # good +# def foo +# bar +# rescue NameError +# baz +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:37 +class RuboCop::Cop::Lint::RescueType < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:60 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:44 + def on_resbody(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:71 + def correction(*exceptions); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:82 + def invalid_exceptions(exceptions); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:78 + def valid_exceptions(exceptions); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:42 +RuboCop::Cop::Lint::RescueType::INVALID_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/rescue_type.rb:40 +RuboCop::Cop::Lint::RescueType::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of a return with a value in a context +# where the value will be ignored. (initialize and setter methods) +# +# @example +# +# # bad +# def initialize +# foo +# return :qux if bar? +# baz +# end +# +# def foo=(bar) +# return 42 +# end +# @example +# +# # good +# def initialize +# foo +# return if bar? +# baz +# end +# +# def foo=(bar) +# return +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/return_in_void_context.rb:34 +class RuboCop::Cop::Lint::ReturnInVoidContext < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/return_in_void_context.rb:37 + def on_return(return_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/return_in_void_context.rb:53 + def non_void_context(return_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/return_in_void_context.rb:35 +RuboCop::Cop::Lint::ReturnInVoidContext::MSG = T.let(T.unsafe(nil), String) + +# The safe navigation operator returns nil if the receiver is +# nil. If you chain an ordinary method call after a safe +# navigation operator, it raises NoMethodError. We should use a +# safe navigation operator after a safe navigation operator. +# This cop checks for the problem outlined above. +# +# @example +# +# # bad +# +# x&.foo.bar +# x&.foo + bar +# x&.foo[bar] +# @example +# +# # good +# +# x&.foo&.bar +# x&.foo || bar +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:26 +class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:36 + def bad_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:43 + def on_send(node); end + + private + + # @param offense_range [Parser::Source::Range] + # @param send_node [RuboCop::AST::SendNode] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:63 + def add_safe_navigation_operator(offense_range:, send_node:); end + + # @param corrector [RuboCop::Cop::Corrector] + # @param offense_range [Parser::Source::Range] + # @param send_node [RuboCop::AST::SendNode] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:81 + def autocorrect(corrector, offense_range:, send_node:); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:91 + def method_chain(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_chain.rb:33 +RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String) + +# Check to make sure that if safe navigation is used for a method +# call in an `&&` or `||` condition that safe navigation is used for all +# method calls on that same object. +# +# @example +# # bad +# foo&.bar && foo.baz +# +# # bad +# foo.bar || foo&.baz +# +# # bad +# foo&.bar && (foobar.baz || foo.baz) +# +# # good +# foo.bar && foo.baz +# +# # good +# foo&.bar || foo&.baz +# +# # good +# foo&.bar && (foobar.baz || foo&.baz) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:29 +class RuboCop::Cop::Lint::SafeNavigationConsistency < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:42 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:36 + def on_csend(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:61 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:67 + def location(node, unsafe_method_call); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:71 + def top_conditional_ancestor(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:82 + def unsafe_method_calls(method_calls, safe_nav_receiver); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_consistency.rb:34 +RuboCop::Cop::Lint::SafeNavigationConsistency::MSG = T.let(T.unsafe(nil), String) + +# Checks to make sure safe navigation isn't used with `empty?` in +# a conditional. +# +# While the safe navigation operator is generally a good idea, when +# checking `foo&.empty?` in a conditional, `foo` being `nil` will actually +# do the opposite of what the author intends. +# +# @example +# # bad +# return if foo&.empty? +# return unless foo&.empty? +# +# # good +# return if foo && foo.empty? +# return unless foo && foo.empty? +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_with_empty.rb:22 +class RuboCop::Cop::Lint::SafeNavigationWithEmpty < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_with_empty.rb:32 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_with_empty.rb:28 + def safe_navigation_empty_in_conditional?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/safe_navigation_with_empty.rb:25 +RuboCop::Cop::Lint::SafeNavigationWithEmpty::MSG = T.let(T.unsafe(nil), String) + +# Checks if a file which has a shebang line as +# its first line is granted execute permission. +# +# @example +# # bad +# +# # A file which has a shebang line as its first line is not +# # granted execute permission. +# +# #!/usr/bin/env ruby +# puts 'hello, world' +# +# # good +# +# # A file which has a shebang line as its first line is +# # granted execute permission. +# +# #!/usr/bin/env ruby +# puts 'hello, world' +# +# # good +# +# # A file which has not a shebang line as its first line is not +# # granted execute permission. +# +# puts 'hello, world' +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:33 +class RuboCop::Cop::Lint::ScriptPermission < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:39 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:55 + def autocorrect(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:59 + def executable?(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:66 + def format_message_from(processed_source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:36 +RuboCop::Cop::Lint::ScriptPermission::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/script_permission.rb:37 +RuboCop::Cop::Lint::ScriptPermission::SHEBANG = T.let(T.unsafe(nil), String) + +# Checks for self-assignments. +# +# @example +# # bad +# foo = foo +# foo, bar = foo, bar +# Foo = Foo +# +# # good +# foo = bar +# foo, bar = bar, foo +# Foo = Bar +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:19 +class RuboCop::Cop::Lint::SelfAssignment < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:53 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:41 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:29 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:29 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:29 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:29 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:49 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:53 + def on_or_asgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:61 + def multiple_self_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:71 + def rhs_matches_lhs?(rhs, lhs); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:22 +RuboCop::Cop::Lint::SelfAssignment::ASSIGNMENT_TYPE_TO_RHS_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/self_assignment.rb:20 +RuboCop::Cop::Lint::SelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# This cop checks for `send`, `public_send`, and `__send__` methods +# when using mix-in. +# +# `include` and `prepend` methods were private methods until Ruby 2.0, +# they were mixed-in via `send` method. This cop uses Ruby 2.1 or +# higher style that can be called by public methods. +# And `extend` method that was originally a public method is also targeted +# for style unification. +# +# @example +# # bad +# Foo.send(:include, Bar) +# Foo.send(:prepend, Bar) +# Foo.send(:extend, Bar) +# +# # bad +# Foo.public_send(:include, Bar) +# Foo.public_send(:prepend, Bar) +# Foo.public_send(:extend, Bar) +# +# # bad +# Foo.__send__(:include, Bar) +# Foo.__send__(:prepend, Bar) +# Foo.__send__(:extend, Bar) +# +# # good +# Foo.include Bar +# Foo.prepend Bar +# Foo.extend Bar +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:37 +class RuboCop::Cop::Lint::SendWithMixinArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:54 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:47 + def send_with_mixin_argument?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:67 + def bad_location(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:73 + def message(method, module_name, bad_method); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:77 + def mixin_method?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:42 +RuboCop::Cop::Lint::SendWithMixinArgument::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:41 +RuboCop::Cop::Lint::SendWithMixinArgument::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:44 +RuboCop::Cop::Lint::SendWithMixinArgument::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/send_with_mixin_argument.rb:43 +RuboCop::Cop::Lint::SendWithMixinArgument::SEND_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for shadowed arguments. +# +# This cop has `IgnoreImplicitReferences` configuration option. +# It means argument shadowing is used in order to pass parameters +# to zero arity `super` when `IgnoreImplicitReferences` is `true`. +# +# @example +# +# # bad +# do_something do |foo| +# foo = 42 +# puts foo +# end +# +# def do_something(foo) +# foo = 42 +# puts foo +# end +# +# # good +# do_something do |foo| +# foo = foo + 42 +# puts foo +# end +# +# def do_something(foo) +# foo = foo + 42 +# puts foo +# end +# +# def do_something(foo) +# puts foo +# end +# @example IgnoreImplicitReferences: false (default) +# +# # bad +# def do_something(foo) +# foo = 42 +# super +# end +# +# def do_something(foo) +# foo = super +# bar +# end +# @example IgnoreImplicitReferences: true +# +# # good +# def do_something(foo) +# foo = 42 +# super +# end +# +# def do_something(foo) +# foo = super +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:66 +class RuboCop::Cop::Lint::ShadowedArgument < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:76 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:70 + def uses_var?(param0, param1); end + + private + + # Get argument references without assignments' references + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:160 + def argument_references(argument); end + + # Find the first argument assignment, which doesn't reference the + # argument at the rhs. If the assignment occurs inside a branch or + # block, it is impossible to tell whether it's executed, so precise + # shadowing location is not known. + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:120 + def assignment_without_argument_usage(argument); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:82 + def check_argument(argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:170 + def ignore_implicit_references?; end + + # Check whether the given node is nested into block or conditional. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:151 + def node_within_block_or_conditional?(node, stop_search_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:143 + def reference_pos(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:95 + def shadowing_assignment(argument); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:72 + def joining_forces; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_argument.rb:67 +RuboCop::Cop::Lint::ShadowedArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for a rescued exception that get shadowed by a +# less specific exception being rescued before a more specific +# exception is rescued. +# +# An exception is considered shadowed if it is rescued after its +# ancestor is, or if it and its ancestor are both rescued in the +# same `rescue` statement. In both cases, the more specific rescue is +# unnecessary because it is covered by rescuing the less specific +# exception. (ie. `rescue Exception, StandardError` has the same behavior +# whether `StandardError` is included or not, because all `StandardError`s +# are rescued by `rescue Exception`). +# +# @example +# +# # bad +# +# begin +# something +# rescue Exception +# handle_exception +# rescue StandardError +# handle_standard_error +# end +# +# # bad +# begin +# something +# rescue Exception, StandardError +# handle_error +# end +# +# # good +# +# begin +# something +# rescue StandardError +# handle_standard_error +# rescue Exception +# handle_exception +# end +# +# # good, however depending on runtime environment. +# # +# # This is a special case for system call errors. +# # System dependent error code depends on runtime environment. +# # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are +# # the same error code or different error code depends on environment. +# # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with +# # the same error code. +# begin +# something +# rescue Errno::EAGAIN, Errno::EWOULDBLOCK +# handle_standard_error +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:61 +class RuboCop::Cop::Lint::ShadowedException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:67 + def on_rescue(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:101 + def compare_exceptions(exception, other_exception); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:94 + def contains_multiple_levels_of_exceptions?(group); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:119 + def evaluate_exceptions(group); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:168 + def find_shadowing_rescue(rescues); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:84 + def offense_range(rescues); end + + # @param rescue_group [RuboCop::AST::Node] is a node of array_type + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:159 + def rescued_exceptions(rescue_group); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:90 + def rescued_groups_for(rescues); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:143 + def sorted?(rescued_groups); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:115 + def system_call_err?(error); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowed_exception.rb:65 +RuboCop::Cop::Lint::ShadowedException::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of local variable names from an outer scope +# in block arguments or block-local variables. This mirrors the warning +# given by `ruby -cw` prior to Ruby 2.6: +# "shadowing outer local variable - foo". +# +# NOTE: Shadowing of variables in block passed to `Ractor.new` is allowed +# because `Ractor` should not access outer variables. +# eg. following style is encouraged: +# +# worker_id, pipe = env +# Ractor.new(worker_id, pipe) do |worker_id, pipe| +# end +# +# @example +# +# # bad +# +# def some_method +# foo = 1 +# +# 2.times do |foo| # shadowing outer `foo` +# do_something(foo) +# end +# end +# @example +# +# # good +# +# def some_method +# foo = 1 +# +# 2.times do |bar| +# do_something(bar) +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:42 +class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:54 + def before_declaring_variable(variable, variable_table); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:77 + def find_conditional_node_from_ascendant(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:46 + def ractor_block?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:66 + def same_conditions_node_different_branch?(variable, outer_local_variable); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:50 + def joining_forces; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb:43 +RuboCop::Cop::Lint::ShadowingOuterLocalVariable::MSG = T.let(T.unsafe(nil), String) + +# Checks unexpected overrides of the `Struct` built-in methods +# via `Struct.new`. +# +# @example +# # bad +# Bad = Struct.new(:members, :clone, :count) +# b = Bad.new([], true, 1) +# b.members #=> [] (overriding `Struct#members`) +# b.clone #=> true (overriding `Object#clone`) +# b.count #=> 1 (overriding `Enumerable#count`) +# +# # good +# Good = Struct.new(:id, :name) +# g = Good.new(1, "foo") +# g.members #=> [:id, :name] +# g.clone #=> #<struct Good id=1, name="foo"> +# g.count #=> 2 +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:24 +class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:38 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:33 + def struct_new(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:25 +RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:27 +RuboCop::Cop::Lint::StructNewOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:30 +RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/struct_new_override.rb:29 +RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array) + +# Checks for `rescue` blocks with no body. +# +# @example +# +# # bad +# def some_method +# do_something +# rescue +# end +# +# # bad +# begin +# do_something +# rescue +# end +# +# # good +# def some_method +# do_something +# rescue +# handle_exception +# end +# +# # good +# begin +# do_something +# rescue +# handle_exception +# end +# @example AllowComments: true (default) +# +# # good +# def some_method +# do_something +# rescue +# # do nothing +# end +# +# # good +# begin +# do_something +# rescue +# # do nothing +# end +# @example AllowComments: false +# +# # bad +# def some_method +# do_something +# rescue +# # do nothing +# end +# +# # bad +# begin +# do_something +# rescue +# # do nothing +# end +# @example AllowNil: true (default) +# +# # good +# def some_method +# do_something +# rescue +# nil +# end +# +# # good +# begin +# do_something +# rescue +# # do nothing +# end +# +# # good +# do_something rescue nil +# @example AllowNil: false +# +# # bad +# def some_method +# do_something +# rescue +# nil +# end +# +# # bad +# begin +# do_something +# rescue +# nil +# end +# +# # bad +# do_something rescue nil +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/suppressed_exception.rb:105 +class RuboCop::Cop::Lint::SuppressedException < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/suppressed_exception.rb:108 + def on_resbody(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/suppressed_exception.rb:118 + def comment_between_rescue_and_end?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/suppressed_exception.rb:126 + def nil_body?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/suppressed_exception.rb:106 +RuboCop::Cop::Lint::SuppressedException::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of literal strings converted to +# a symbol where a literal symbol could be used instead. +# +# There are two possible styles for this cop. +# `strict` (default) will register an offense for any incorrect usage. +# `consistent` additionally requires hashes to use the same style for +# every symbol key (ie. if any symbol key needs to be quoted it requires +# all keys to be quoted). +# +# @example +# # bad +# 'string'.to_sym +# :symbol.to_sym +# 'underscored_string'.to_sym +# :'underscored_symbol' +# 'hyphenated-string'.to_sym +# +# # good +# :string +# :symbol +# :underscored_string +# :underscored_symbol +# :'hyphenated-string' +# @example EnforcedStyle: strict (default) +# +# # bad +# { +# 'a': 1, +# "b": 2, +# 'c-d': 3 +# } +# +# # good (don't quote keys that don't require quoting) +# { +# a: 1, +# b: 2, +# 'c-d': 3 +# } +# @example EnforcedStyle: consistent +# +# # bad +# { +# a: 1, +# 'b-c': 2 +# } +# +# # good (quote all keys if any need quoting) +# { +# 'a': 1, +# 'b-c': 2 +# } +# +# # good (no quoting required) +# { +# a: 1, +# b: 2 +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:66 +class RuboCop::Cop::Lint::SymbolConversion < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SymbolHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:100 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:76 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:83 + def on_sym(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:142 + def correct_hash_key(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:161 + def correct_inconsistent_hash_keys(keys); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:134 + def in_alias?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:138 + def in_percent_literal_array?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:121 + def properly_quoted?(source, value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:117 + def register_offense(node, correction:, message: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:130 + def requires_quotes?(sym_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:71 +RuboCop::Cop::Lint::SymbolConversion::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:72 +RuboCop::Cop::Lint::SymbolConversion::MSG_CONSISTENCY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/symbol_conversion.rb:74 +RuboCop::Cop::Lint::SymbolConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Repacks Parser's diagnostics/errors +# into RuboCop's offenses. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/syntax.rb:8 +class RuboCop::Cop::Lint::Syntax < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/syntax.rb:9 + def on_other_file; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/syntax.rb:19 + def add_offense_from_diagnostic(diagnostic, ruby_version); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/syntax.rb:26 + def add_offense_from_error(error); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/syntax.rb:31 + def beautify_message(message); end +end + +# Ensures that `to_enum`/`enum_for`, called for the current method, +# has correct arguments. +# +# @example +# # bad +# def foo(x, y = 1) +# return to_enum(__callee__, x) # `y` is missing +# end +# +# # good +# def foo(x, y = 1) +# return to_enum(__callee__, x, y) +# # alternatives to `__callee__` are `__method__` and `:foo` +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:21 +class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:27 + def enum_conversion_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:32 + def method_name?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:41 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:37 + def passing_keyword_arg?(param0 = T.unsafe(nil), param1); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:68 + def argument_match?(send_arg, def_arg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:53 + def arguments_match?(arguments, def_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:22 +RuboCop::Cop::Lint::ToEnumArguments::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/to_enum_arguments.rb:24 +RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks to make sure `#to_json` includes an optional argument. +# When overriding `#to_json`, callers may invoke JSON +# generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows +# for an optional argument, your method should too. +# +# @example +# class Point +# attr_reader :x, :y +# +# # bad, incorrect arity +# def to_json +# JSON.generate([x, y]) +# end +# +# # good, preserving args +# def to_json(*args) +# JSON.generate([x, y], *args) +# end +# +# # good, discarding args +# def to_json(*_args) +# JSON.generate([x, y]) +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/to_json.rb:31 +class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/to_json.rb:36 + def on_def(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/to_json.rb:34 +RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String) + +# Checks for top level return with arguments. If there is a +# top-level return statement with an argument, then the argument is +# always ignored. This is detected automatically since Ruby 2.7. +# +# @example +# +# # Detected since Ruby 2.7 +# return 1 # 1 is always ignored. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/top_level_return_with_argument.rb:17 +class RuboCop::Cop::Lint::TopLevelReturnWithArgument < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/top_level_return_with_argument.rb:21 + def on_return(return_node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/top_level_return_with_argument.rb:27 + def ancestors_valid?(return_node); end +end + +# This cop works by validating the ancestors of the return node. A +# top-level return node's ancestors should not be of block, def, or +# defs type. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/top_level_return_with_argument.rb:19 +RuboCop::Cop::Lint::TopLevelReturnWithArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing commas in attribute declarations, such as +# `#attr_reader`. Leaving a trailing comma will nullify the next method +# definition by overriding it with a getter method. +# +# @example +# +# # bad +# class Foo +# attr_reader :foo, +# +# def bar +# puts "Unreachable." +# end +# end +# +# # good +# class Foo +# attr_reader :foo +# +# def bar +# puts "No problem!" +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb:30 +class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb:36 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb:46 + def trailing_comma_range(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/trailing_comma_in_attribute_declaration.rb:34 +RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::MSG = T.let(T.unsafe(nil), String) + +# Checks for "triple quotes" (strings delimited by any odd number +# of quotes greater than 1). +# +# Ruby allows multiple strings to be implicitly concatenated by just +# being adjacent in a statement (ie. `"foo""bar" == "foobar"`). This sometimes +# gives the impression that there is something special about triple quotes, but +# in fact it is just extra unnecessary quotes and produces the same string. Each +# pair of quotes produces an additional concatenated empty string, so the result +# is still only the "actual" string within the delimiters. +# +# NOTE: Although this cop is called triple quotes, the same behavior is present +# for strings delimited by 5, 7, etc. quotation marks. +# +# @example +# # bad +# """ +# A string +# """ +# +# # bad +# ''' +# A string +# ''' +# +# # good +# " +# A string +# " +# +# # good +# <<STRING +# A string +# STRING +# +# # good (but not the same spacing as the bad case) +# 'A string' +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/triple_quotes.rb:42 +class RuboCop::Cop::Lint::TripleQuotes < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/triple_quotes.rb:47 + def on_dstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/triple_quotes.rb:65 + def empty_str_nodes(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/triple_quotes.rb:45 +RuboCop::Cop::Lint::TripleQuotes::MSG = T.let(T.unsafe(nil), String) + +# Checks for underscore-prefixed variables that are actually +# used. +# +# Since block keyword arguments cannot be arbitrarily named at call +# sites, the `AllowKeywordBlockArguments` will allow use of underscore- +# prefixed block keyword arguments. +# +# @example AllowKeywordBlockArguments: false (default) +# +# # bad +# +# [1, 2, 3].each do |_num| +# do_something(_num) +# end +# +# query(:sales) do |_id:, revenue:, cost:| +# {_id: _id, profit: revenue - cost} +# end +# +# # good +# +# [1, 2, 3].each do |num| +# do_something(num) +# end +# +# [1, 2, 3].each do |_num| +# do_something # not using `_num` +# end +# @example AllowKeywordBlockArguments: true +# +# # good +# +# query(:sales) do |_id:, revenue:, cost:| +# {_id: _id, profit: revenue - cost} +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:43 +class RuboCop::Cop::Lint::UnderscorePrefixedVariableName < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:50 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:54 + def check_variable(variable); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:72 + def allowed_keyword_block_argument?(variable); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:46 + def joining_forces; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb:44 +RuboCop::Cop::Lint::UnderscorePrefixedVariableName::MSG = T.let(T.unsafe(nil), String) + +# Checks for a block that is known to need more positional +# block arguments than are given (by default this is configured for +# `Enumerable` methods needing 2 arguments). Optional arguments are allowed, +# although they don't generally make sense as the default value will +# be used. Blocks that have no receiver, or take splatted arguments +# (ie. `*args`) are always accepted. +# +# Keyword arguments (including `**kwargs`) do not get counted towards +# this, as they are not used by the methods in question. +# +# Method names and their expected arity can be configured like this: +# +# [source,yaml] +# ---- +# Methods: +# inject: 2 +# reduce: 2 +# ---- +# +# @example +# # bad +# values.reduce {} +# values.min { |a| a } +# values.sort { |a; b| a + b } +# +# # good +# values.reduce { |memo, obj| memo << obj } +# values.min { |a, b| a <=> b } +# values.sort { |*x| x[0] <=> x[1] } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:41 +class RuboCop::Cop::Lint::UnexpectedBlockArity < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:44 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:44 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:63 + def acceptable?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:75 + def arg_count(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:71 + def expected_arity(method); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:67 + def included_method?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:59 + def methods; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unexpected_block_arity.rb:42 +RuboCop::Cop::Lint::UnexpectedBlockArity::MSG = T.let(T.unsafe(nil), String) + +# Checks for using Fixnum or Bignum constant. +# +# @example +# +# # bad +# +# 1.is_a?(Fixnum) +# 1.is_a?(Bignum) +# @example +# +# # good +# +# 1.is_a?(Integer) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unified_integer.rb:20 +class RuboCop::Cop::Lint::UnifiedInteger < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unified_integer.rb:26 + def fixnum_or_bignum_const(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unified_integer.rb:30 + def on_const(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unified_integer.rb:23 +RuboCop::Cop::Lint::UnifiedInteger::MSG = T.let(T.unsafe(nil), String) + +# Looks for `reduce` or `inject` blocks where the value returned (implicitly or +# explicitly) does not include the accumulator. A block is considered valid as +# long as at least one return value includes the accumulator. +# +# If the accumulator is not included in the return value, then the entire +# block will just return a transformation of the last element value, and +# could be rewritten as such without a loop. +# +# Also catches instances where an index of the accumulator is returned, as +# this may change the type of object being retained. +# +# NOTE: For the purpose of reducing false positives, this cop only flags +# returns in `reduce` blocks where the element is the only variable in +# the expression (since we will not be able to tell what other variables +# relate to via static analysis). +# +# @example +# +# # bad +# (1..4).reduce(0) do |acc, el| +# el * 2 +# end +# +# # bad, may raise a NoMethodError after the first iteration +# %w(a b c).reduce({}) do |acc, letter| +# acc[letter] = true +# end +# +# # good +# (1..4).reduce(0) do |acc, el| +# acc + el * 2 +# end +# +# # good, element is returned but modified using the accumulator +# values.reduce do |acc, el| +# el << acc +# el +# end +# +# # good, returns the accumulator instead of the index +# %w(a b c).reduce({}) do |acc, letter| +# acc[letter] = true +# acc +# end +# +# # good, at least one branch returns the accumulator +# values.reduce(nil) do |result, value| +# break result if something? +# value +# end +# +# # good, recursive +# keys.reduce(self) { |result, key| result[key] } +# +# # ignored as the return value cannot be determined +# enum.reduce do |acc, el| +# x = foo(acc, el) +# bar(x) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:65 +class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:78 + def accumulator_index?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:83 + def element_modified?(param0, param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:104 + def expression_values(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:93 + def lvar_used?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:115 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:115 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:70 + def reduce_with_block?(param0 = T.unsafe(nil)); end + + private + + # Determine if a return value is acceptable for the purposes of this cop + # If it is an expression containing the accumulator, it is acceptable + # Otherwise, it is only unacceptable if it contains the iterated element, since we + # otherwise do not have enough information to prevent false positives. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:190 + def acceptable_return?(return_val, element_name); end + + # Exclude `begin` nodes inside a `dstr` from being collected by `return_values` + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:198 + def allowed_type?(parent_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:158 + def block_arg_name(node, index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:141 + def check_return_values(block_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:175 + def potential_offense?(return_values, block_body, element_name, accumulator_name); end + + # Return values in a block are either the value given to next, + # the last line of a multiline block, or the only line of the block + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:127 + def return_values(block_body_node); end + + # Look for an index of the accumulator being returned, except where the index + # is the element. + # This is always an offense, in order to try to catch potential exceptions + # due to type mismatches + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:166 + def returned_accumulator_index(return_values, accumulator_name, element_name); end + + # If the accumulator is used in any return value, the node is acceptable since + # the accumulator has a chance to change each iteration + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:182 + def returns_accumulator_anywhere?(return_values, accumulator_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:66 +RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb:67 +RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::MSG_INDEX = T.let(T.unsafe(nil), String) + +# Checks for unreachable code. +# The check are based on the presence of flow of control +# statement in non-final position in `begin` (implicit) blocks. +# +# @example +# +# # bad +# +# def some_method +# return +# do_something +# end +# +# # bad +# +# def some_method +# if cond +# return +# else +# return +# end +# do_something +# end +# @example +# +# # good +# +# def some_method +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:37 +class RuboCop::Cop::Lint::UnreachableCode < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:55 + def flow_command?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:40 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:40 + def on_kwbegin(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:87 + def check_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:81 + def check_if(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:65 + def flow_expression?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_code.rb:38 +RuboCop::Cop::Lint::UnreachableCode::MSG = T.let(T.unsafe(nil), String) + +# Checks for loops that will have at most one iteration. +# +# A loop that can never reach the second iteration is a possible error in the code. +# In rare cases where only one iteration (or at most one iteration) is intended behavior, +# the code should be refactored to use `if` conditionals. +# +# NOTE: Block methods that are used with `Enumerable`s are considered to be loops. +# +# `AllowedPatterns` can be used to match against the block receiver in order to allow +# code that would otherwise be registered as an offense (eg. `times` used not in an +# `Enumerable` context). +# +# @example +# # bad +# while node +# do_something(node) +# node = node.parent +# break +# end +# +# # good +# while node +# do_something(node) +# node = node.parent +# end +# +# # bad +# def verify_list(head) +# item = head +# begin +# if verify(item) +# return true +# else +# return false +# end +# end while(item) +# end +# +# # good +# def verify_list(head) +# item = head +# begin +# if verify(item) +# item = item.next +# else +# return false +# end +# end while(item) +# +# true +# end +# +# # bad +# def find_something(items) +# items.each do |item| +# if something?(item) +# return item +# else +# raise NotFoundError +# end +# end +# end +# +# # good +# def find_something(items) +# items.each do |item| +# if something?(item) +# return item +# end +# end +# raise NotFoundError +# end +# +# # bad +# 2.times { raise ArgumentError } +# @example AllowedPatterns: [/(exactly|at_least|at_most)\(\d+\)\.times/] (default) +# +# # good +# exactly(2).times { raise StandardError } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:86 +class RuboCop::Cop::Lint::UnreachableLoop < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:143 + def break_command?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:100 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:92 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:104 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:92 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:92 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:92 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:92 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:153 + def break_statement?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:119 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:176 + def check_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:170 + def check_if(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:194 + def conditional_continue_keyword?(break_statement); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:110 + def loop_method?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:184 + def preceded_by_continue_statement?(break_statement); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:130 + def statements(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:90 +RuboCop::Cop::Lint::UnreachableLoop::CONTINUE_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unreachable_loop.rb:89 +RuboCop::Cop::Lint::UnreachableLoop::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for cops handling unused arguments. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/unused_argument.rb:7 +module RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/unused_argument.rb:10 + def after_leaving_scope(scope, _variable_table); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/unused_argument.rb:16 + def check_argument(variable); end +end + +# Checks for unused block arguments. +# +# @example +# # bad +# do_something do |used, unused| +# puts used +# end +# +# do_something do |bar| +# puts :foo +# end +# +# define_method(:foo) do |bar| +# puts :baz +# end +# +# # good +# do_something do |used, _unused| +# puts used +# end +# +# do_something do +# puts :foo +# end +# +# define_method(:foo) do |_bar| +# puts :baz +# end +# @example IgnoreEmptyBlocks: true (default) +# # good +# do_something { |unused| } +# @example IgnoreEmptyBlocks: false +# # bad +# do_something { |unused| } +# @example AllowUnusedKeywordArguments: false (default) +# # bad +# do_something do |unused: 42| +# foo +# end +# @example AllowUnusedKeywordArguments: true +# # good +# do_something do |unused: 42| +# foo +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:55 +class RuboCop::Cop::Lint::UnusedBlockArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:162 + def allow_unused_keyword_arguments?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:81 + def allowed_block?(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:85 + def allowed_keyword_argument?(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:99 + def augment_message(message, variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:65 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:69 + def check_argument(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:149 + def define_method_call?(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:156 + def empty_block?(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:166 + def ignore_empty_blocks?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:89 + def message(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:132 + def message_for_lambda(variable, all_arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:120 + def message_for_normal_block(variable, all_arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:144 + def message_for_underscore_prefix(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:77 + def used_block_local?(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:112 + def variable_type(variable); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_block_argument.rb:59 + def joining_forces; end + end +end + +# Checks for unused method arguments. +# +# @example +# # bad +# def some_method(used, unused, _unused_but_allowed) +# puts used +# end +# +# # good +# def some_method(used, _unused, _unused_but_allowed) +# puts used +# end +# @example AllowUnusedKeywordArguments: false (default) +# # bad +# def do_something(used, unused: 42) +# used +# end +# @example AllowUnusedKeywordArguments: true +# # good +# def do_something(used, unused: 42) +# used +# end +# @example IgnoreEmptyMethods: true (default) +# # good +# def do_something(unused) +# end +# @example IgnoreEmptyMethods: false +# # bad +# def do_something(unused) +# end +# @example IgnoreNotImplementedMethods: true (default) +# # good +# def do_something(unused) +# raise NotImplementedError +# end +# +# def do_something_else(unused) +# fail "TODO" +# end +# @example IgnoreNotImplementedMethods: false +# # bad +# def do_something(unused) +# raise NotImplementedError +# end +# +# def do_something_else(unused) +# fail "TODO" +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:61 +class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:66 + def not_implemented?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:77 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:81 + def check_argument(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:89 + def ignored_method?(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:94 + def message(variable); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/unused_method_argument.rb:71 + def joining_forces; end + end +end + +# Identifies places where `URI.escape` can be replaced by +# `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component` +# depending on your specific use case. +# Also this cop identifies places where `URI.unescape` can be replaced by +# `CGI.unescape`, `URI.decode_www_form`, +# or `URI.decode_www_form_component` depending on your specific use case. +# +# @example +# # bad +# URI.escape('http://example.com') +# URI.encode('http://example.com') +# +# # good +# CGI.escape('http://example.com') +# URI.encode_www_form([['example', 'param'], ['lang', 'en']]) +# URI.encode_www_form(page: 10, locale: 'en') +# URI.encode_www_form_component('http://example.com') +# +# # bad +# URI.unescape(enc_uri) +# URI.decode(enc_uri) +# +# # good +# CGI.unescape(enc_uri) +# URI.decode_www_form(enc_uri) +# URI.decode_www_form_component(enc_uri) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:32 +class RuboCop::Cop::Lint::UriEscapeUnescape < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:57 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:51 + def uri_escape_unescape?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:33 +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_ESCAPE = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:38 +RuboCop::Cop::Lint::UriEscapeUnescape::ALTERNATE_METHODS_OF_URI_UNESCAPE = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:47 +RuboCop::Cop::Lint::UriEscapeUnescape::METHOD_NAMES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:44 +RuboCop::Cop::Lint::UriEscapeUnescape::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_escape_unescape.rb:48 +RuboCop::Cop::Lint::UriEscapeUnescape::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `URI.regexp` is obsolete and should +# not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`. +# +# @example +# # bad +# URI.regexp('http://example.com') +# +# # good +# URI::DEFAULT_PARSER.make_regexp('http://example.com') +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_regexp.rb:16 +class RuboCop::Cop::Lint::UriRegexp < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_regexp.rb:23 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_regexp.rb:19 +RuboCop::Cop::Lint::UriRegexp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_regexp.rb:21 +RuboCop::Cop::Lint::UriRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/uri_regexp.rb:20 +RuboCop::Cop::Lint::UriRegexp::URI_CONSTANTS = T.let(T.unsafe(nil), Array) + +# Checks for redundant access modifiers, including those with no +# code, those which are repeated, and leading `public` modifiers in a +# class or module body. Conditionally-defined methods are considered as +# always being defined, and thus access modifiers guarding such methods +# are not redundant. +# +# This cop has `ContextCreatingMethods` option. The default setting value +# is an empty array that means no method is specified. +# This setting is an array of methods which, when called, are known to +# create its own context in the module's current access context. +# +# It also has `MethodCreatingMethods` option. The default setting value +# is an empty array that means no method is specified. +# This setting is an array of methods which, when called, are known to +# create other methods in the module's current access context. +# +# @example +# # bad +# class Foo +# public # this is redundant (default access is public) +# +# def method +# end +# end +# +# # bad +# class Foo +# # The following is redundant (methods defined on the class' +# # singleton class are not affected by the public modifier) +# public +# +# def self.method3 +# end +# end +# +# # bad +# class Foo +# protected +# +# define_method(:method2) do +# end +# +# protected # this is redundant (repeated from previous modifier) +# +# [1,2,3].each do |i| +# define_method("foo#{i}") do +# end +# end +# end +# +# # bad +# class Foo +# private # this is redundant (no following methods are defined) +# end +# +# # good +# class Foo +# private # this is not redundant (a method is defined) +# +# def method2 +# end +# end +# +# # good +# class Foo +# # The following is not redundant (conditionally defined methods are +# # considered as always defining a method) +# private +# +# if condition? +# def method +# end +# end +# end +# +# # good +# class Foo +# protected # this is not redundant (a method is defined) +# +# define_method(:method2) do +# end +# end +# @example ContextCreatingMethods: concerning +# # Lint/UselessAccessModifier: +# # ContextCreatingMethods: +# # - concerning +# +# # good +# require 'active_support/concern' +# class Foo +# concerning :Bar do +# def some_public_method +# end +# +# private +# +# def some_private_method +# end +# end +# +# # this is not redundant because `concerning` created its own context +# private +# +# def some_other_private_method +# end +# end +# @example MethodCreatingMethods: delegate +# # Lint/UselessAccessModifier: +# # MethodCreatingMethods: +# # - delegate +# +# # good +# require 'active_support/core_ext/module/delegation' +# class Foo +# # this is not redundant because `delegate` creates methods +# private +# +# delegate :method_a, to: :method_b +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:127 +class RuboCop::Cop::Lint::UselessAccessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:166 + def class_or_instance_eval?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:171 + def class_or_module_or_struct_new_call?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:161 + def dynamic_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:139 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:133 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:133 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:139 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:133 + def on_sclass(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:156 + def static_method_definition?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:187 + def access_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:277 + def any_context_creating_methods?(child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:254 + def any_method_definition?(child); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:149 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:200 + def check_child_nodes(node, unused, cur_vis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:227 + def check_new_visibility(node, unused, new_vis, cur_vis); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:175 + def check_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:191 + def check_scope(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:216 + def check_send_node(node, cur_vis, unused); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:271 + def eval_call?(child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:248 + def method_definition?(child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:267 + def start_of_new_scope?(child); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_access_modifier.rb:131 +RuboCop::Cop::Lint::UselessAccessModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for every useless assignment to local variable in every +# scope. +# The basic idea for this cop was from the warning of `ruby -cw`: +# +# assigned but unused variable - foo +# +# Currently this cop has advanced logic that detects unreferenced +# reassignments and properly handles varied cases such as branch, loop, +# rescue, ensure, etc. +# +# @example +# +# # bad +# +# def some_method +# some_var = 1 +# do_something +# end +# @example +# +# # good +# +# def some_method +# some_var = 1 +# do_something(some_var) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:33 +class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:40 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:44 + def check_for_unused_assignments(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:108 + def collect_variable_like_names(scope); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:62 + def message_for_useless_assignment(assignment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:68 + def message_specification(assignment, variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:78 + def multiple_assignment_message(variable_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:83 + def operator_assignment_message(scope, assignment); end + + # TODO: More precise handling (rescue, ensure, nested begin, etc.) + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:98 + def return_value_node_of_scope(scope); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:91 + def similar_name_message(variable); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:117 + def variable_like_method_invocation?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:36 + def joining_forces; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_assignment.rb:34 +RuboCop::Cop::Lint::UselessAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for useless `else` in `begin..end` without `rescue`. +# +# NOTE: This syntax is no longer valid on Ruby 2.6 or higher. +# +# @example +# +# # bad +# +# begin +# do_something +# else +# do_something_else # This will never be run. +# end +# @example +# +# # good +# +# begin +# do_something +# rescue +# handle_errors +# else +# do_something_else +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_else_without_rescue.rb:31 +class RuboCop::Cop::Lint::UselessElseWithoutRescue < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_else_without_rescue.rb:34 + def on_new_investigation; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_else_without_rescue.rb:32 +RuboCop::Cop::Lint::UselessElseWithoutRescue::MSG = T.let(T.unsafe(nil), String) + +# Checks for useless method definitions, specifically: empty constructors +# and methods just delegating to `super`. +# +# @example +# # bad +# def initialize +# super +# end +# +# def method +# super +# end +# +# # good - with default arguments +# def initialize(x = Object.new) +# super +# end +# +# # good +# def initialize +# super +# initialize_internals +# end +# +# def method(*args) +# super(:extra_arg, *args) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:38 +class RuboCop::Cop::Lint::UselessMethodDefinition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:43 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:43 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:57 + def delegating?(node, def_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:53 + def optional_args?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_method_definition.rb:41 +RuboCop::Cop::Lint::UselessMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Looks for `ruby2_keywords` calls for methods that do not need it. +# +# `ruby2_keywords` should only be called on methods that accept an argument splat +# (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or +# a keyword splat (`**kwargs`). +# +# @example +# # good (splat argument without keyword arguments) +# ruby2_keywords def foo(*args); end +# +# # bad (no arguments) +# ruby2_keywords def foo; end +# +# # good +# def foo; end +# +# # bad (positional argument) +# ruby2_keywords def foo(arg); end +# +# # good +# def foo(arg); end +# +# # bad (double splatted argument) +# ruby2_keywords def foo(**args); end +# +# # good +# def foo(**args); end +# +# # bad (keyword arguments) +# ruby2_keywords def foo(i:, j:); end +# +# # good +# def foo(i:, j:); end +# +# # bad (splat argument with keyword arguments) +# ruby2_keywords def foo(*args, i:, j:); end +# +# # good +# def foo(*args, i:, j:); end +# +# # bad (splat argument with double splat) +# ruby2_keywords def foo(*args, **kwargs); end +# +# # good +# def foo(*args, **kwargs); end +# +# # bad (ruby2_keywords given a symbol) +# def foo; end +# ruby2_keywords :foo +# +# # good +# def foo; end +# +# # bad (ruby2_keywords with dynamic method) +# define_method(:foo) { |arg| } +# ruby2_keywords :foo +# +# # good +# define_method(:foo) { |arg| } +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:66 +class RuboCop::Cop::Lint::UselessRuby2Keywords < ::RuboCop::Cop::Base + # Looks for statically or dynamically defined methods with a given name + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:72 + def method_definition(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:79 + def on_send(node); end + + private + + # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:108 + def allowed_arguments(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:89 + def inspect_def(node, def_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:95 + def inspect_sym(node, sym_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:67 +RuboCop::Cop::Lint::UselessRuby2Keywords::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_ruby2_keywords.rb:68 +RuboCop::Cop::Lint::UselessRuby2Keywords::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for setter call to local variable as the final +# expression of a function definition. +# +# @example +# +# # bad +# +# def something +# x = Something.new +# x.attr = 5 +# end +# @example +# +# # good +# +# def something +# x = Something.new +# x.attr = 5 +# x +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:35 +class RuboCop::Cop::Lint::UselessSetterCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:41 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:41 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:63 + def setter_call_to_local_variable?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:67 + def last_expression(body); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:39 +RuboCop::Cop::Lint::UselessSetterCall::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:38 +RuboCop::Cop::Lint::UselessSetterCall::MSG = T.let(T.unsafe(nil), String) + +# This class tracks variable assignments in a method body +# and if a variable contains object passed as argument at the end of +# the method. +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:76 +class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker + # @return [MethodVariableTracker] a new instance of MethodVariableTracker + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:77 + def initialize(body_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:163 + def constructor?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:82 + def contain_local_object?(variable_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:152 + def process_assignment(asgn_node, rhs_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:100 + def process_assignment_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:142 + def process_binary_operator_assignment(op_asgn_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:133 + def process_logical_operator_assignment(asgn_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:114 + def process_multiple_assignment(masgn_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_setter_call.rb:92 + def scan(node, &block); end +end + +# Checks for uses of `Integer#times` that will never yield +# (when the integer <= 0) or that will only ever yield once +# (`1.times`). +# +# @example +# # bad +# -5.times { do_something } +# 0.times { do_something } +# 1.times { do_something } +# 1.times { |i| do_something(i) } +# +# # good +# do_something +# do_something(1) +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:24 +class RuboCop::Cop::Lint::UselessTimes < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:37 + def block_arg(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:42 + def block_reassigns_arg?(param0, param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:46 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:32 + def times_call?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:62 + def autocorrect(corrector, count, node, proc_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:84 + def autocorrect_block(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:80 + def autocorrect_block_pass(corrector, node, proc_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:94 + def fix_indentation(source, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:72 + def never_process?(count, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:106 + def own_line?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:76 + def remove_node(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:28 +RuboCop::Cop::Lint::UselessTimes::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/useless_times.rb:29 +RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for operators, variables, literals, and nonmutating +# methods used in void context. +# +# @example CheckForMethodsWithNoSideEffects: false (default) +# # bad +# def some_method +# some_num * 10 +# do_something +# end +# +# def some_method(some_var) +# some_var +# do_something +# end +# @example CheckForMethodsWithNoSideEffects: true +# # bad +# def some_method(some_array) +# some_array.sort +# do_something(some_array) +# end +# +# # good +# def some_method +# do_something +# some_num * 10 +# end +# +# def some_method(some_var) +# do_something +# some_var +# end +# +# def some_method(some_array) +# some_array.sort! +# do_something(some_array) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:43 +class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:72 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:63 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:72 + def on_kwbegin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:63 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:79 + def check_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:120 + def check_defined(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:85 + def check_expression(expr); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:108 + def check_literal(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:126 + def check_nonmutating(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:114 + def check_self(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:102 + def check_var(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:96 + def check_void_op(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:132 + def in_void_context?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:51 +RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:48 +RuboCop::Cop::Lint::Void::DEFINED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:46 +RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:55 +RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:49 +RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:53 +RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:44 +RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:47 +RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:52 +RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:45 +RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/lint/void.rb:54 +RuboCop::Cop::Lint::Void::VOID_CONTEXT_TYPES = T.let(T.unsafe(nil), Array) + +# Common functionality for obtaining source ranges from regexp matches +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/match_range.rb:6 +module RuboCop::Cop::MatchRange + include ::RuboCop::Cop::RangeHelp + + private + + # Return a new `Range` covering the first matching group number for each + # match of `regex` inside `range` + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/match_range.rb:13 + def each_match_range(range, regex); end + + # For a `match` inside `range`, return a new `Range` covering the match + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/match_range.rb:18 + def match_range(range, match); end +end + +# Message Annotator class annotates a basic offense message +# based on params passed into initializer. +# +# #=> 'Cop/CopName: message (http://example.org/styleguide)' +# +# @example +# RuboCop::Cop::MessageAnnotator.new( +# config, cop_name, cop_config, @options +# ).annotate('message') +# @see #initialize +# +# source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:15 +class RuboCop::Cop::MessageAnnotator + # @option cop_config + # @option cop_config + # @option cop_config + # @option options + # @option options + # @option options + # @option options + # @param config [RuboCop::Config] Check configs for all cops + # @note Message Annotator specifically checks the + # following config options for_all_cops + # :StyleGuideBaseURL [String] URL for styleguide + # :DisplayStyleGuide [Boolean] Include styleguide and reference URLs + # :ExtraDetails [Boolean] Include cop details + # :DisplayCopNames [Boolean] Include cop name + # @param cop_name [String] for specific cop name + # @param cop_config [Hash] configs for specific cop, from config#for_cop + # @param options [Hash, nil] optional + # @return [MessageAnnotator] a new instance of MessageAnnotator + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:47 + def initialize(config, cop_name, cop_config, options); end + + # Returns the annotated message, + # based on params passed into initializer + # + # @return [String] annotated message + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:58 + def annotate(message); end + + # Returns the value of attribute config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:16 + def config; end + + # Returns the value of attribute cop_config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:16 + def cop_config; end + + # Returns the value of attribute cop_name. + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:16 + def cop_name; end + + # Returns the value of attribute options. + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:16 + def options; end + + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:68 + def urls; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:111 + def debug?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:124 + def details; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:115 + def display_cop_names?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:98 + def display_style_guide?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:107 + def extra_details?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:102 + def reference_urls; end + + # Returns the base style guide URL from AllCops or the specific department + # + # @return [String] style guide URL + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:91 + def style_guide_base_url; end + + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:74 + def style_guide_url; end + + class << self + # Returns the value of attribute style_guide_urls. + # + # source://rubocop-1.35.1/lib/rubocop/cop/message_annotator.rb:21 + def style_guide_urls; end + end +end + +# This module handles measurement and reporting of complexity in methods. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:8 +module RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + extend ::RuboCop::AST::NodePattern::Macros + extend ::RuboCop::ExcludeLimit + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:37 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:24 + def on_block(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:17 + def on_def(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:17 + def on_defs(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:24 + def on_numblock(node); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:42 + def check_complexity(node, method_name); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_complexity.rb:61 + def complexity(body); end +end + +# Common code for cops that deal with preferred methods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_preference.rb:6 +module RuboCop::Cop::MethodPreference + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_preference.rb:25 + def default_cop_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_preference.rb:9 + def preferred_method(method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/method_preference.rb:13 + def preferred_methods; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:5 +module RuboCop::Cop::Metrics; end + +# Checks that the ABC size of methods is not higher than the +# configured maximum. The ABC size is based on assignments, branches +# (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric +# and https://en.wikipedia.org/wiki/ABC_Software_Metric. +# +# Interpreting ABC size: +# +# * <= 17 satisfactory +# * 18..30 unsatisfactory +# * > 30 dangerous +# +# You can have repeated "attributes" calls count as a single "branch". +# For this purpose, attributes are any method with no argument; no attempt +# is meant to distinguish actual `attr_reader` from other methods. +# +# This cop also takes into account `AllowedMethods` (defaults to `[]`) +# And `AllowedPatterns` (defaults to `[]`) +# +# @example CountRepeatedAttributes: false (default is true) +# +# # `model` and `current_user`, refenced 3 times each, +# # are each counted as only 1 branch each if +# # `CountRepeatedAttributes` is set to 'false' +# +# def search +# @posts = model.active.visible_by(current_user) +# .search(params[:q]) +# @posts = model.some_process(@posts, current_user) +# @posts = model.another_process(@posts, current_user) +# +# render 'pages/search/page' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/abc_size.rb:39 +class RuboCop::Cop::Metrics::AbcSize < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + include ::RuboCop::Cop::MethodComplexity + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/abc_size.rb:47 + def complexity(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/abc_size.rb:42 +RuboCop::Cop::Metrics::AbcSize::MSG = T.let(T.unsafe(nil), String) + +# Checks if the length of a block exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# The cop can be configured to ignore blocks passed to certain methods. +# +# You can set literals you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', and 'heredoc'. Each literal +# will be counted as one line regardless of its actual size. +# +# +# NOTE: The `ExcludedMethods` configuration is deprecated and only kept +# for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns` +# instead. By default, there are no methods to allowed. +# +# NOTE: This cop does not apply for `Struct` definitions. +# +# @example CountAsOne: ['array', 'heredoc'] +# +# something do +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# msg = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# end # 5 points +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:39 +class RuboCop::Cop::Metrics::BlockLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:46 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:46 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:75 + def cop_label; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:57 + def method_receiver_excluded?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_length.rb:44 +RuboCop::Cop::Metrics::BlockLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks for excessive nesting of conditional and looping +# constructs. +# +# You can configure if blocks are considered using the `CountBlocks` +# option. When set to `false` (the default) blocks are not counted +# towards the nesting level. Set to `true` to count blocks as well. +# +# The maximum level of nesting allowed is configurable. +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:14 +class RuboCop::Cop::Metrics::BlockNesting < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:19 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:28 + def check_nesting_level(node, max, current_level); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:44 + def consider_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:54 + def count_blocks?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:50 + def message(max); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/block_nesting.rb:15 +RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array) + +# Checks if the length a class exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# +# You can set literals you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', and 'heredoc'. Each literal +# will be counted as one line regardless of its actual size. +# +# NOTE: This cop also applies for `Struct` definitions. +# +# @example CountAsOne: ['array', 'heredoc'] +# +# class Foo +# ARRAY = [ # +1 +# 1, +# 2 +# ] +# +# HASH = { # +3 +# key: 'value' +# } +# +# MSG = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# end # 5 points +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/class_length.rb:34 +class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/class_length.rb:41 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/class_length.rb:37 + def on_class(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/class_length.rb:59 + def message(length, max_length); end +end + +# Checks that the cyclomatic complexity of methods is not higher +# than the configured maximum. The cyclomatic complexity is the number of +# linearly independent paths through a method. The algorithm counts +# decision points and adds one. +# +# An if statement (or unless or ?:) increases the complexity by one. An +# else branch does not, since it doesn't add a decision point. The && +# operator (or keyword and) can be converted to a nested if statement, +# and ||/or is shorthand for a sequence of ifs, so they also add one. +# Loops can be said to have an exit condition, so they add one. +# Blocks that are calls to builtin iteration methods +# (e.g. `ary.map{...}) also add one, others are ignored. +# +# def each_child_node(*types) # count begins: 1 +# unless block_given? # unless: +1 +# return to_enum(__method__, *types) +# +# children.each do |child| # each{}: +1 +# next unless child.is_a?(Node) # unless: +1 +# +# yield child if types.empty? || # if: +1, ||: +1 +# types.include?(child.type) +# end +# +# self +# end # total: 6 +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb:32 +class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + include ::RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::Metrics::Utils::IteratingBlock + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb:42 + def complexity_score_for(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb:49 + def count_block?(block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb:37 +RuboCop::Cop::Metrics::CyclomaticComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/cyclomatic_complexity.rb:36 +RuboCop::Cop::Metrics::CyclomaticComplexity::MSG = T.let(T.unsafe(nil), String) + +# Checks if the length of a method exceeds some maximum value. +# Comment lines can optionally be allowed. +# The maximum allowed length is configurable. +# +# You can set literals you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', and 'heredoc'. Each literal +# will be counted as one line regardless of its actual size. +# +# NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is +# deprecated and only kept for backwards compatibility. +# Please use `AllowedMethods` and `AllowedPatterns` instead. +# By default, there are no methods to allowed. +# +# @example CountAsOne: ['array', 'heredoc'] +# +# def m +# array = [ # +1 +# 1, +# 2 +# ] +# +# hash = { # +3 +# key: 'value' +# } +# +# <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# end # 5 points +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:37 +class RuboCop::Cop::Metrics::MethodLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:51 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:44 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:44 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:51 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:60 + def cop_label; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/method_length.rb:42 +RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String) + +# Checks if the length a module exceeds some maximum value. +# Comment lines can optionally be ignored. +# The maximum allowed length is configurable. +# +# You can set literals you want to fold with `CountAsOne`. +# Available are: 'array', 'hash', and 'heredoc'. Each literal +# will be counted as one line regardless of its actual size. +# +# @example CountAsOne: ['array', 'heredoc'] +# +# module M +# ARRAY = [ # +1 +# 1, +# 2 +# ] +# +# HASH = { # +3 +# key: 'value' +# } +# +# MSG = <<~HEREDOC # +1 +# Heredoc +# content. +# HEREDOC +# end # 5 points +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/module_length.rb:32 +class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CodeLength + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/module_length.rb:46 + def module_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/module_length.rb:39 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/module_length.rb:35 + def on_module(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/module_length.rb:50 + def message(length, max_length); end +end + +# Checks for methods with too many parameters. +# +# The maximum number of parameters is configurable. +# Keyword arguments can optionally be excluded from the total count, +# as they add less complexity than positional or optional parameters. +# +# NOTE: Explicit block argument `&block` is not counted to prevent +# erroneous change that is avoided by making block argument implicit. +# +# This cop also checks for the maximum number of optional parameters. +# This can be configured using the `MaxOptionalParameters` config option. +# +# @example Max: 3 +# # good +# def foo(a, b, c = 1) +# end +# @example Max: 2 +# # bad +# def foo(a, b, c = 1) +# end +# @example CountKeywordArgs: true (default) +# # counts keyword args towards the maximum +# +# # bad (assuming Max is 3) +# def foo(a, b, c, d: 1) +# end +# +# # good (assuming Max is 3) +# def foo(a, b, c: 1) +# end +# @example CountKeywordArgs: false +# # don't count keyword args towards the maximum +# +# # good (assuming Max is 3) +# def foo(a, b, c, d: 1) +# end +# @example MaxOptionalParameters: 3 (default) +# # good +# def foo(a = 1, b = 2, c = 3) +# end +# @example MaxOptionalParameters: 2 +# # bad +# def foo(a = 1, b = 2, c = 3) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:56 +class RuboCop::Cop::Metrics::ParameterLists < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:94 + def argument_to_lambda_or_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max_optional_parameters=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:80 + def on_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:66 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:66 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:98 + def args_count(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:114 + def count_keyword_args?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:110 + def max_optional_parameters; end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:106 + def max_params; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:60 +RuboCop::Cop::Metrics::ParameterLists::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:63 +RuboCop::Cop::Metrics::ParameterLists::NAMED_KEYWORD_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/parameter_lists.rb:61 +RuboCop::Cop::Metrics::ParameterLists::OPTIONAL_PARAMETERS_MSG = T.let(T.unsafe(nil), String) + +# Tries to produce a complexity score that's a measure of the +# complexity the reader experiences when looking at a method. For that +# reason it considers `when` nodes as something that doesn't add as much +# complexity as an `if` or a `&&`. Except if it's one of those special +# `case`/`when` constructs where there's no expression after `case`. Then +# the cop treats it as an `if`/`elsif`/`elsif`... and lets all the `when` +# nodes count. In contrast to the CyclomaticComplexity cop, this cop +# considers `else` nodes as adding complexity. +# +# @example +# +# def my_method # 1 +# if cond # 1 +# case var # 2 (0.8 + 4 * 0.2, rounded) +# when 1 then func_one +# when 2 then func_two +# when 3 then func_three +# when 4..10 then func_other +# end +# else # 1 +# do_something until a && b # 2 +# end # === +# end # 7 complexity points +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/perceived_complexity.rb:29 +class RuboCop::Cop::Metrics::PerceivedComplexity < ::RuboCop::Cop::Metrics::CyclomaticComplexity + private + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/perceived_complexity.rb:36 + def complexity_score_for(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/perceived_complexity.rb:32 +RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/perceived_complexity.rb:30 +RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:6 +module RuboCop::Cop::Metrics::Utils; end + +# > ABC is .. a software size metric .. computed by counting the number +# > of assignments, branches and conditions for a section of code. +# > http://c2.com/cgi/wiki?AbcMetric +# +# We separate the *calculator* from the *cop* so that the calculation, +# the formula itself, is easier to test. +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:13 +class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + include ::RuboCop::AST::Sexp + include ::RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount + include ::RuboCop::Cop::Metrics::Utils::IteratingBlock + include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + + # @return [AbcSizeCalculator] a new instance of AbcSizeCalculator + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:30 + def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:45 + def calculate; end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:53 + def calculate_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:68 + def else_branch?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:47 + def evaluate_branch_nodes(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:63 + def evaluate_condition_node(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:131 + def argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:89 + def assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:127 + def branch?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:122 + def capturing_variable?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:98 + def compound_assignment(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:135 + def condition?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:111 + def simple_assignment?(node); end + + # @yield [node] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:74 + def visit_depth_last(node, &block); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:28 + def calculate(node, discount_repeated_attributes: T.unsafe(nil)); end + end +end + +# TODO: move to rubocop-ast +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:33 +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) + +# > Branch -- an explicit forward program branch out of scope -- a +# > function call, class method call .. +# > http://c2.com/cgi/wiki?AbcMetric +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:21 +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::BRANCH_NODES = T.let(T.unsafe(nil), Array) + +# > Condition -- a logical/Boolean test, == != <= >= < > else case +# > default try catch ? and unary conditionals. +# > http://c2.com/cgi/wiki?AbcMetric +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:26 +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::CONDITION_NODES = T.let(T.unsafe(nil), Array) + +# Helps to calculate code length for the provided node. +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:8 +class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + extend ::RuboCop::AST::NodePattern::Macros + + # @return [CodeLengthCalculator] a new instance of CodeLengthCalculator + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:16 + def initialize(node, processed_source, count_comments: T.unsafe(nil), foldable_types: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:24 + def calculate; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:172 + def another_args?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:42 + def build_foldable_checks(types); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:80 + def classlike_code_length(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:128 + def classlike_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:63 + def code_length(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:153 + def count_comments?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:116 + def each_top_level_descendant(node, types, &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:136 + def extract_body(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:132 + def foldable_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:111 + def heredoc_length(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:76 + def heredoc_node?(node); end + + # Returns true for lines that shall not be included in the count. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:149 + def irrelevant_line?(source_line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:100 + def line_numbers_of_inner_nodes(node, *types); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:96 + def namespace_module?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:58 + def normalize_foldable_types(types); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:157 + def omit_length(descendant); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:168 + def parenthesized?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:13 +RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::CLASSLIKE_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb:12 +RuboCop::Cop::Metrics::Utils::CodeLengthCalculator::FOLDABLE_TYPES = T.let(T.unsafe(nil), Array) + +# Used to identify iterating blocks like `.map{}` and `.map(&:...)` +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/iterating_block.rb:8 +module RuboCop::Cop::Metrics::Utils::IteratingBlock + # Returns the name of the method called with a block + # if node is a block node, or a block-pass node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/iterating_block.rb:37 + def block_method_name(node); end + + # Returns nil if node is neither a block node or a block-pass node. + # Otherwise returns true/false if method call is a known iterating call + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/iterating_block.rb:53 + def iterating_block?(node); end + + # Returns true iff name is a known iterating type (e.g. :each, :transform_values) + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/iterating_block.rb:47 + def iterating_method?(name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/iterating_block.rb:33 +RuboCop::Cop::Metrics::Utils::IteratingBlock::KNOWN_ITERATING_METHODS = T.let(T.unsafe(nil), Set) + +# Identifies repetitions `{c}send` calls with no arguments: +# +# foo.bar +# foo.bar # => repeated +# foo.bar.baz.qux # => inner send repeated +# foo.bar.baz.other # => both inner send repeated +# foo.bar(2) # => not repeated +# +# It also invalidates sequences if a receiver is reassigned: +# +# xx.foo.bar +# xx.foo.baz # => inner send repeated +# self.xx = any # => invalidates everything so far +# xx.foo.baz # => no repetition +# self.xx.foo.baz # => all repeated +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:25 +module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount + include ::RuboCop::AST::Sexp + extend ::RuboCop::AST::NodePattern::Macros + + # Plug into the calculator + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:30 + def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:61 + def attribute_call?(param0 = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:53 + def calculate_node(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:43 + def discount_repeated_attributes?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:47 + def evaluate_branch_nodes(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:92 + def root_node?(param0 = T.unsafe(nil)); end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:66 + def discount_repeated_attribute?(send_node); end + + # Returns the "known_attributes" for the `node` by walking the receiver tree + # If at any step the subdirectory does not exist, it is yielded with the + # associated key (method_name) + # If the node is not a series of `(c)send` calls with no arguments, + # then `nil` is yielded + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:103 + def find_attributes(node, &block); end + + # or `nil` if it is not a setter. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:126 + def setter_to_getter(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:80 + def update_repeated_attribute(node); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb:117 +RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount::VAR_SETTER_TO_GETTER = T.let(T.unsafe(nil), Hash) + +# Identifies repetitions `&.` on the same variable: +# +# my_var&.foo +# my_var&.bar # => repeated +# my_var = baz # => reset +# my_var&.qux # => not repeated +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:15 +module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:20 + def discount_for_repeated_csend?(csend_node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:34 + def reset_on_lvasgn(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:16 + def reset_repeated_csend; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:5 +module RuboCop::Cop::Migration; end + +# department name. +# +# source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:8 +class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:21 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:47 + def check_cop_name(name, comment, offset); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:69 + def contain_unexpected_character_for_department_name?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:43 + def disable_comment_offset; end + + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:73 + def qualified_legacy_cop_name(cop_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:63 + def valid_content_token?(content_token); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:14 +RuboCop::Cop::Migration::DepartmentName::DISABLE_COMMENT_FORMAT = T.let(T.unsafe(nil), Regexp) + +# The token that makes up a disable comment. +# `DepartmentName/CopName` or` all`. +# +# source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:19 +RuboCop::Cop::Migration::DepartmentName::DISABLING_COPS_CONTENT_TOKEN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/migration/department_name.rb:12 +RuboCop::Cop::Migration::DepartmentName::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking minimum body length. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/min_body_length.rb:6 +module RuboCop::Cop::MinBodyLength + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/min_body_length.rb:13 + def min_body_length; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/min_body_length.rb:9 + def min_body_length?(node); end +end + +# Common code for indenting the first elements in multiline +# array literals, hash literals, and method definitions. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:7 +module RuboCop::Cop::MultilineElementIndentation + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:42 + def check_expected_style(styles); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:26 + def check_first(first, left_brace, left_parenthesis, offset); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:80 + def detected_styles(actual_column, offset, left_parenthesis, left_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:85 + def detected_styles_for_column(column, left_parenthesis, left_brace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:10 + def each_argument_node(node, type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:66 + def hash_pair_where_value_beginning_with(left_brace, first); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:98 + def incorrect_style_detected(styles, first, base_column_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:50 + def indent_base(left_brace, first, left_parenthesis); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:72 + def key_and_value_begin_on_same_line?(pair); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_indentation.rb:76 + def right_sibling_begins_on_subsequent_line?(pair); end +end + +# Common functionality for checking for a line break before each +# element in a multi-line collection. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:10 +module RuboCop::Cop::MultilineElementLineBreaks + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:26 + def all_on_same_line?(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:13 + def check_line_breaks(_node, children); end +end + +# Common functionality for checking multiline method calls and binary +# operations. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:7 +module RuboCop::Cop::MultilineExpressionIndentation + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:14 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:131 + def argument_in_method_call(node, kind); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:187 + def assignment_rhs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:64 + def check(range, node, lhs, rhs); end + + # The correct indentation of `node` is usually `IndentationWidth`, with + # one exception: prefix keywords. + # + # ``` + # while foo && # Here, `while` is called a "prefix keyword" + # bar # This is called "special indentation" + # baz + # end + # ``` + # + # Note that *postfix conditionals* do *not* get "special indentation". + # + # ``` + # next if foo && + # bar # normal indentation, not special + # ``` + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:54 + def correct_indentation(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:159 + def disqualified_rhs?(candidate, ancestor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:203 + def grouped_expression?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:72 + def incorrect_style_detected(range, node, lhs, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:84 + def indentation(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:121 + def indented_keyword_expression(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:207 + def inside_arg_list_parentheses?(node, ancestor); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:98 + def keyword_message_tail(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:106 + def kw_node_with_special_indentation(node); end + + # In a chain of method calls, we regard the top send node as the base + # for indentation of all lines following the first. For example: + # a. + # b c { block }. <-- b is indented relative to a + # d <-- d is indented relative to a + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:31 + def left_hand_side(lhs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:197 + def not_for_this_cop?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:88 + def operation_description(node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:145 + def part_of_assignment_rhs(node, candidate); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:183 + def part_of_block_body?(candidate, block_node); end + + # Returns true if `node` is a conditional whose `body` and `condition` + # begin on the same line. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:216 + def postfix_conditional?(node); end + + # The []= operator and setters (a.b = c) are parsed as :send nodes. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:175 + def valid_method_rhs_candidate?(candidate, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:164 + def valid_rhs?(candidate, ancestor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:179 + def valid_rhs_candidate?(candidate, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:220 + def within_node?(inner, outer); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:11 +RuboCop::Cop::MultilineExpressionIndentation::ASSIGNMENT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:10 +RuboCop::Cop::MultilineExpressionIndentation::DEFAULT_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:8 +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:12 +RuboCop::Cop::MultilineExpressionIndentation::KEYWORD_MESSAGE_TAIL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_expression_indentation.rb:9 +RuboCop::Cop::MultilineExpressionIndentation::UNALIGNED_RHS_TYPES = T.let(T.unsafe(nil), Array) + +# Autocorrection logic for the closing brace of a literal either +# on the same line as the last contained elements, or a new line. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:7 +class RuboCop::Cop::MultilineLiteralBraceCorrector + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::RangeHelp + + # @return [MultilineLiteralBraceCorrector] a new instance of MultilineLiteralBraceCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:15 + def initialize(corrector, node, processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:21 + def call; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:52 + def content_if_comment_present(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:43 + def correct_next_line_brace(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:39 + def correct_same_line_brace(corrector); end + + # Returns the value of attribute corrector. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:37 + def corrector; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:78 + def last_element_range_with_trailing_comma(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:87 + def last_element_trailing_comma_range(node); end + + # Returns the value of attribute node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:37 + def node; end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:37 + def processed_source; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:74 + def remove_trailing_content_of_comment(corrector, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:64 + def select_content_to_be_inserted_after_last_element(corrector, node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb:11 + def correct(corrector, node, processed_source); end + end +end + +# Common functionality for checking the closing brace of a literal is +# either on the same line as the last contained elements or a new line. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:7 +module RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:34 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:12 + def check_brace_layout(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:42 + def check_new_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:50 + def check_same_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:58 + def check_symmetrical(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:86 + def children(node); end + + # This method depends on the fact that we have guarded + # against implicit and empty literals. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:98 + def closing_brace_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:74 + def empty_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:82 + def ignored_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:78 + def implicit_literal?(node); end + + # Starting with the parent node and recursively for the parent node's + # children, check if the node is a HEREDOC and if the HEREDOC ends below + # or on the last line of the parent node. + # + # Example: + # + # # node is `b: ...` parameter + # # last_line_heredoc?(node) => false + # foo(a, + # b: { + # a: 1, + # c: <<-EOM + # baz + # EOM + # } + # ) + # + # # node is `b: ...` parameter + # # last_line_heredoc?(node) => true + # foo(a, + # b: <<-EOM + # baz + # EOM + # ) + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:126 + def last_line_heredoc?(node, parent = T.unsafe(nil)); end + + # Returns true for the case + # [a, + # b # comment + # ].some_method + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:26 + def new_line_needed_before_closing_brace?(node); end + + # This method depends on the fact that we have guarded + # against implicit and empty literals. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:92 + def opening_brace_on_same_line?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:5 +module RuboCop::Cop::Naming; end + +# Makes sure that accessor methods are named properly. Applies +# to both instance and class methods. +# +# NOTE: Offenses are only registered for methods with the expected +# arity. Getters (`get_attribute`) must have no arguments to be +# registered, and setters (`set_attribute(value)`) must have exactly +# one. +# +# @example +# # bad +# def set_attribute(value) +# end +# +# # good +# def attribute=(value) +# end +# +# # bad +# def get_attribute +# end +# +# # good +# def attribute +# end +# +# # accepted, incorrect arity for getter +# def get_value(attr) +# end +# +# # accepted, incorrect arity for setter +# def set_value +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:38 +class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:42 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:42 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:61 + def bad_reader_name?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:65 + def bad_writer_name?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:53 + def message(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:39 +RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/accessor_method_name.rb:40 +RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String) + +# Checks for non-ascii characters in identifier and constant names. +# Identifiers are always checked and whether constants are checked +# can be controlled using AsciiConstants config. +# +# @example +# # bad +# def καλημερα # Greek alphabet (non-ascii) +# end +# +# # bad +# def こんにちはと言う # Japanese character (non-ascii) +# end +# +# # bad +# def hello_🍣 # Emoji (non-ascii) +# end +# +# # good +# def say_hello +# end +# +# # bad +# 신장 = 10 # Hangul character (non-ascii) +# +# # good +# height = 10 +# +# # bad +# params[:عرض_gteq] # Arabic character (non-ascii) +# +# # good +# params[:width_gteq] +# @example AsciiConstants: true (default) +# # bad +# class Foö +# end +# +# FOÖ = "foo" +# @example AsciiConstants: false +# # good +# class Foö +# end +# +# FOÖ = "foo" +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:53 +class RuboCop::Cop::Naming::AsciiIdentifiers < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:59 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:84 + def first_non_ascii_chars(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:74 + def first_offense_range(identifier); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:70 + def should_check?(token); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:57 +RuboCop::Cop::Naming::AsciiIdentifiers::CONSTANT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/ascii_identifiers.rb:56 +RuboCop::Cop::Naming::AsciiIdentifiers::IDENTIFIER_MSG = T.let(T.unsafe(nil), String) + +# Makes sure that certain binary operator methods have their +# sole parameter named `other`. +# +# @example +# +# # bad +# def +(amount); end +# +# # good +# def +(other); end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:16 +class RuboCop::Cop::Naming::BinaryOperatorParameterName < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:29 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:25 + def op_method_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:45 + def op_method?(name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:22 +RuboCop::Cop::Naming::BinaryOperatorParameterName::EXCLUDED = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:19 +RuboCop::Cop::Naming::BinaryOperatorParameterName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/binary_operator_parameter_name.rb:21 +RuboCop::Cop::Naming::BinaryOperatorParameterName::OP_LIKE_METHODS = T.let(T.unsafe(nil), Array) + +# In Ruby 3.1, anonymous block forwarding has been added. +# +# This cop identifies places where `do_something(&block)` can be replaced +# by `do_something(&)`. +# +# It also supports the opposite style by alternative `explicit` option. +# You can specify the block variable name for autocorrection with `BlockForwardingName`. +# The default variable name is `block`. If the name is already in use, it will not be +# autocorrected. +# +# @example EnforcedStyle: anonymous (default) +# +# # bad +# def foo(&block) +# bar(&block) +# end +# +# # good +# def foo(&) +# bar(&) +# end +# @example EnforcedStyle: explicit +# +# # bad +# def foo(&) +# bar(&) +# end +# +# # good +# def foo(&block) +# bar(&block) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:40 +class RuboCop::Cop::Naming::BlockForwarding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:50 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:50 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:83 + def anonymous_block_argument?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:115 + def block_forwarding_name; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:69 + def expected_block_forwarding_style?(node, last_argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:87 + def explicit_block_argument?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:91 + def register_offense(block_argument, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:107 + def use_block_argument_as_local_variable?(node, last_argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:79 + def use_kwarg_in_method_definition?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/block_forwarding.rb:48 +RuboCop::Cop::Naming::BlockForwarding::MSG = T.let(T.unsafe(nil), String) + +# Checks block parameter names for how descriptive they +# are. It is highly configurable. +# +# The `MinNameLength` config option takes an integer. It represents +# the minimum amount of characters the name must be. Its default is 1. +# The `AllowNamesEndingInNumbers` config option takes a boolean. When +# set to false, this cop will register offenses for names ending with +# numbers. Its default is false. The `AllowedNames` config option +# takes an array of permitted names that will never register an +# offense. The `ForbiddenNames` config option takes an array of +# restricted names that will always register an offense. +# +# @example +# # bad +# bar do |varOne, varTwo| +# varOne + varTwo +# end +# +# # With `AllowNamesEndingInNumbers` set to false +# foo { |num1, num2| num1 * num2 } +# +# # With `MinNameLength` set to number greater than 1 +# baz { |a, b, c| do_stuff(a, b, c) } +# +# # good +# bar do |thud, fred| +# thud + fred +# end +# +# foo { |speed, distance| speed * distance } +# +# baz { |age, height, gender| do_stuff(age, height, gender) } +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/block_parameter_name.rb:38 +class RuboCop::Cop::Naming::BlockParameterName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::UncommunicativeName + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/block_parameter_name.rb:41 + def on_block(node); end +end + +# Checks for class and module names with +# an underscore in them. +# +# `AllowedNames` config takes an array of permitted names. +# Its default value is `['module_parent']`. +# These names can be full class/module names or part of the name. +# eg. Adding `my_class` to the `AllowedNames` config will allow names like +# `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc. +# +# @example +# # bad +# class My_Class +# end +# module My_Module +# end +# +# # good +# class MyClass +# end +# module MyModule +# end +# class module_parent::MyModule +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/class_and_module_camel_case.rb:29 +class RuboCop::Cop::Naming::ClassAndModuleCamelCase < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/naming/class_and_module_camel_case.rb:32 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/class_and_module_camel_case.rb:32 + def on_module(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/class_and_module_camel_case.rb:30 +RuboCop::Cop::Naming::ClassAndModuleCamelCase::MSG = T.let(T.unsafe(nil), String) + +# Checks whether constant names are written using +# SCREAMING_SNAKE_CASE. +# +# To avoid false positives, it ignores cases in which we cannot know +# for certain the type of value that would be assigned to a constant. +# +# @example +# # bad +# InchInCm = 2.54 +# INCHinCM = 2.54 +# Inch_In_Cm = 2.54 +# +# # good +# INCH_IN_CM = 2.54 +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:20 +class RuboCop::Cop::Naming::ConstantName < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:27 + def class_or_struct_return_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:69 + def literal_receiver?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:33 + def on_casgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:56 + def allowed_assignment?(value); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:74 + def allowed_conditional_expression_on_rhs?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:63 + def allowed_method_call_on_rhs?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:78 + def contains_constant?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:21 +RuboCop::Cop::Naming::ConstantName::MSG = T.let(T.unsafe(nil), String) + +# Use POSIX character classes, so we allow accented characters rather +# than just standard ASCII characters +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/constant_name.rb:24 +RuboCop::Cop::Naming::ConstantName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +# Makes sure that Ruby source files have snake_case +# names. Ruby scripts (i.e. source files with a shebang in the +# first line) are ignored. +# +# The cop also ignores `.gemspec` files, because Bundler +# recommends using dashes to separate namespaces in nested gems +# (i.e. `bundler-console` becomes `Bundler::Console`). As such, the +# gemspec is supposed to be named `bundler-console.gemspec`. +# +# When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires +# each file to have a class, module or `Struct` defined in it that matches +# the filename. This can be further configured using +# `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the +# path should match the namespace of the above definition. +# +# When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start +# with a shebang line are not considered by the cop. +# +# When `Regex` is set, the cop will flag any filename that does not match +# the regular expression. +# +# @example +# # bad +# lib/layoutManager.rb +# +# anything/usingCamelCase +# +# # good +# lib/layout_manager.rb +# +# anything/using_snake_case.rake +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:39 +class RuboCop::Cop::Naming::FileName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:56 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:49 + def struct_definition(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:134 + def allowed_acronyms; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:96 + def bad_filename_allowed?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:122 + def check_definition_path_hierarchy?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:169 + def defined_struct(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:126 + def definition_path_hierarchy_roots; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:118 + def expect_matching_definition?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:138 + def filename_good?(basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:147 + def find_class_or_module(node, namespace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:165 + def find_definition(node); end + + # @yield [source_range(processed_source.buffer, 1, 0), msg] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:65 + def for_bad_filename(file_path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:114 + def ignore_executable_scripts?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:202 + def match?(expected); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:206 + def match_acronym?(expected, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:174 + def match_namespace(node, namespace, expected); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:92 + def matching_class?(file_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:88 + def matching_definition?(file_path); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:100 + def no_definition_message(basename, file_path); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:106 + def other_message(basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:188 + def partial_matcher!(expected); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:77 + def perform_class_and_module_naming_checks(file_path, basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:130 + def regex; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:240 + def to_module_name(basename); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:213 + def to_namespace(path); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:43 +RuboCop::Cop::Naming::FileName::MSG_NO_DEFINITION = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:44 +RuboCop::Cop::Naming::FileName::MSG_REGEX = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:42 +RuboCop::Cop::Naming::FileName::MSG_SNAKE_CASE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/file_name.rb:46 +RuboCop::Cop::Naming::FileName::SNAKE_CASE = T.let(T.unsafe(nil), Regexp) + +# Checks that your heredocs are using the configured case. +# By default it is configured to enforce uppercase heredocs. +# +# @example EnforcedStyle: uppercase (default) +# # bad +# <<-sql +# SELECT * FROM foo +# sql +# +# # good +# <<-SQL +# SELECT * FROM foo +# SQL +# @example EnforcedStyle: lowercase +# # bad +# <<-SQL +# SELECT * FROM foo +# SQL +# +# # good +# <<-sql +# SELECT * FROM foo +# sql +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:30 +class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:37 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:54 + def correct_case_delimiters?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:58 + def correct_delimiters(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:50 + def message(_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_case.rb:35 +RuboCop::Cop::Naming::HeredocDelimiterCase::MSG = T.let(T.unsafe(nil), String) + +# Checks that your heredocs are using meaningful delimiters. +# By default it disallows `END` and `EO*`, and can be configured through +# forbidden listing additional delimiters. +# +# @example +# +# # good +# <<-SQL +# SELECT * FROM foo +# SQL +# +# # bad +# <<-END +# SELECT * FROM foo +# END +# +# # bad +# <<-EOS +# SELECT * FROM foo +# EOS +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:26 +class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:31 + def on_heredoc(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:49 + def forbidden_delimiters; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:39 + def meaningful_delimiters?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:29 +RuboCop::Cop::Naming::HeredocDelimiterNaming::MSG = T.let(T.unsafe(nil), String) + +# This cops recommends the use of inclusive language instead of problematic terms. +# The cop can check the following locations for offenses: +# - identifiers +# - constants +# - variables +# - strings +# - symbols +# - comments +# - file paths +# Each of these locations can be individually enabled/disabled via configuration, +# for example CheckIdentifiers = true/false. +# +# Flagged terms are configurable for the cop. For each flagged term an optional +# Regex can be specified to identify offenses. Suggestions for replacing a flagged term can +# be configured and will be displayed as part of the offense message. +# An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term. +# `WholeWord: true` can be set on a flagged term to indicate the cop should only match when +# a term matches the whole word (partial matches will not be offenses). +# +# @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } } +# # Suggest replacing identifier whitelist with allowlist +# +# # bad +# whitelist_users = %w(user1 user1) +# +# # good +# allowlist_users = %w(user1 user2) +# @example FlaggedTerms: { master: { Suggestions: ['main', 'primary', 'leader'] } } +# # Suggest replacing master in an instance variable name with main, primary, or leader +# +# # bad +# @master_node = 'node1.example.com' +# +# # good +# @primary_node = 'node1.example.com' +# @example FlaggedTerms: { whitelist: { Regex: !ruby/regexp '/white[-_\s]?list' } } +# # Identify problematic terms using a Regexp +# +# # bad +# white_list = %w(user1 user2) +# +# # good +# allow_list = %w(user1 user2) +# @example FlaggedTerms: { master: { AllowedRegex: 'master\'?s degree' } } +# # Specify allowed uses of the flagged term as a string or regexp. +# +# # bad +# # They had a masters +# +# # good +# # They had a master's degree +# @example FlaggedTerms: { slave: { WholeWord: true } } +# # Specify that only terms that are full matches will be flagged. +# +# # bad +# Slave +# +# # good (won't be flagged despite containing `slave`) +# TeslaVehicle +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:69 +class RuboCop::Cop::Naming::InclusiveLanguage < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # @return [InclusiveLanguage] a new instance of InclusiveLanguage + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:78 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:87 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:105 + def add_offenses_for_token(token, word_locations); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:154 + def add_to_flagged_term_hash(regex_string, term, term_definition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:180 + def array_to_ignorecase_regex(strings); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:113 + def check_token?(type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:228 + def create_message(word, message = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:205 + def create_multiple_word_message_for_file(words); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:201 + def create_single_word_message_for_file(word); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:176 + def ensure_regex_string(regex); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:147 + def extract_regexp(term, term_definition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:236 + def find_flagged_term(word); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:250 + def format_suggestions(suggestions); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:184 + def investigate_filepath; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:94 + def investigate_tokens; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:216 + def mask_input(str); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:117 + def preprocess_check_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:131 + def preprocess_flagged_terms; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:243 + def preprocess_suggestions(suggestions); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:166 + def process_allowed_regex(allowed); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:209 + def scan_for_words(input); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:161 + def set_regexes(flagged_term_strings, allowed_strings); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:72 +RuboCop::Cop::Naming::InclusiveLanguage::EMPTY_ARRAY = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:73 +RuboCop::Cop::Naming::InclusiveLanguage::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:74 +RuboCop::Cop::Naming::InclusiveLanguage::MSG_FOR_FILE_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:76 +class RuboCop::Cop::Naming::InclusiveLanguage::WordLocation < ::Struct + # Returns the value of attribute position + # + # @return [Object] the current value of position + def position; end + + # Sets the attribute position + # + # @param value [Object] the value to set the attribute position to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:76 + def position=(_); end + + # Returns the value of attribute word + # + # @return [Object] the current value of word + def word; end + + # Sets the attribute word + # + # @param value [Object] the value to set the attribute word to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/inclusive_language.rb:76 + def word=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Checks for memoized methods whose instance variable name +# does not match the method name. Applies to both regular methods +# (defined with `def`) and dynamic methods (defined with +# `define_method` or `define_singleton_method`). +# +# This cop can be configured with the EnforcedStyleForLeadingUnderscores +# directive. It can be configured to allow for memoized instance variables +# prefixed with an underscore. Prefixing ivars with an underscore is a +# convention that is used to implicitly indicate that an ivar should not +# be set or referenced outside of the memoization method. +# +# @example EnforcedStyleForLeadingUnderscores: disallowed (default) +# # bad +# # Method foo is memoized using an instance variable that is +# # not `@foo`. This can cause confusion and bugs. +# def foo +# @something ||= calculate_expensive_thing +# end +# +# def foo +# return @something if defined?(@something) +# @something = calculate_expensive_thing +# end +# +# # good +# def _foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= begin +# calculate_expensive_thing +# end +# end +# +# # good +# def foo +# helper_variable = something_we_need_to_calculate_foo +# @foo ||= calculate_expensive_thing(helper_variable) +# end +# +# # good +# define_method(:foo) do +# @foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# return @foo if defined?(@foo) +# @foo = calculate_expensive_thing +# end +# @example EnforcedStyleForLeadingUnderscores: required +# # bad +# def foo +# @something ||= calculate_expensive_thing +# end +# +# # bad +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# def foo +# return @foo if defined?(@foo) +# @foo = calculate_expensive_thing +# end +# +# # good +# def foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def _foo +# @_foo ||= calculate_expensive_thing +# end +# +# def foo +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# @example EnforcedStyleForLeadingUnderscores :optional +# # bad +# def foo +# @something ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def _foo +# @_foo ||= calculate_expensive_thing +# end +# +# # good +# def foo +# return @_foo if defined?(@_foo) +# @_foo = calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @foo ||= calculate_expensive_thing +# end +# +# # good +# define_method(:foo) do +# @_foo ||= calculate_expensive_thing +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:147 +class RuboCop::Cop::Naming::MemoizedInstanceVariableName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:189 + def defined_memoized?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:157 + def method_definition?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:197 + def on_defined?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:166 + def on_or_asgn(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:227 + def find_definition(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:238 + def matches?(method_name, ivar_assign); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:248 + def message(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:223 + def style_parameter_name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:256 + def suggested_var(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:262 + def variable_name_candidates(method_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:154 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::DYNAMIC_DEFINE_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:150 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/memoized_instance_variable_name.rb:152 +RuboCop::Cop::Naming::MemoizedInstanceVariableName::UNDERSCORE_REQUIRED = T.let(T.unsafe(nil), String) + +# Makes sure that all methods use the configured style, +# snake_case or camelCase, for their names. +# +# This cop has `AllowedPatterns` configuration option. +# +# Naming/MethodName: +# AllowedPatterns: +# - '\A\s*onSelectionBulkChange\s*' +# - '\A\s*onSelectionCleared\s*' +# +# Method names matching patterns are always allowed. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# def fooBar; end +# +# # good +# def foo_bar; end +# @example EnforcedStyle: camelCase +# # bad +# def foo_bar; end +# +# # good +# def fooBar; end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:31 +class RuboCop::Cop::Naming::MethodName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:55 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:55 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:44 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:42 + def str_name(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:39 + def sym_name(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:64 + def attr_name(name_item); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:75 + def message(style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:68 + def range_position(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/method_name.rb:36 +RuboCop::Cop::Naming::MethodName::MSG = T.let(T.unsafe(nil), String) + +# Checks method parameter names for how descriptive they +# are. It is highly configurable. +# +# The `MinNameLength` config option takes an integer. It represents +# the minimum amount of characters the name must be. Its default is 3. +# The `AllowNamesEndingInNumbers` config option takes a boolean. When +# set to false, this cop will register offenses for names ending with +# numbers. Its default is false. The `AllowedNames` config option +# takes an array of permitted names that will never register an +# offense. The `ForbiddenNames` config option takes an array of +# restricted names that will always register an offense. +# +# @example +# # bad +# def bar(varOne, varTwo) +# varOne + varTwo +# end +# +# # With `AllowNamesEndingInNumbers` set to false +# def foo(num1, num2) +# num1 * num2 +# end +# +# # With `MinNameLength` set to number greater than 1 +# def baz(a, b, c) +# do_stuff(a, b, c) +# end +# +# # good +# def bar(thud, fred) +# thud + fred +# end +# +# def foo(speed, distance) +# speed * distance +# end +# +# def baz(age_a, height_b, gender_c) +# do_stuff(age_a, height_b, gender_c) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/method_parameter_name.rb:46 +class RuboCop::Cop::Naming::MethodParameterName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::UncommunicativeName + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_parameter_name.rb:49 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/method_parameter_name.rb:49 + def on_defs(node); end +end + +# Checks that predicate methods names end with a question mark and +# do not start with a forbidden prefix. +# +# A method is determined to be a predicate method if its name starts +# with one of the prefixes defined in the `NamePrefix` configuration. +# You can change what prefixes are considered by changing this option. +# Any method name that starts with one of these prefixes is required by +# the cop to end with a `?`. Other methods can be allowed by adding to +# the `AllowedMethods` configuration. +# +# NOTE: The `is_a?` method is allowed by default. +# +# If `ForbiddenPrefixes` is set, methods that start with the configured +# prefixes will not be allowed and will be removed by autocorrection. +# +# In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo` +# will register an offense only due to the lack of question mark (and will be +# autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`, +# `is_foo` will register an offense both because the ? is missing and because of +# the `is_` prefix, and will be corrected to `foo?`. +# +# NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`; +# a prefix in the former but not the latter will not be considered by +# this cop. +# +# @example +# # bad +# def is_even(value) +# end +# +# def is_even?(value) +# end +# +# # good +# def even?(value) +# end +# +# # bad +# def has_value +# end +# +# def has_value? +# end +# +# # good +# def value? +# end +# @example AllowedMethods: ['is_a?'] (default) +# # good +# def is_a?(value) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:59 +class RuboCop::Cop::Naming::PredicateName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:63 + def dynamic_method_define(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:82 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:82 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:69 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:98 + def allowed_method_name?(method_name, prefix); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:106 + def expected_name(method_name, prefix); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:120 + def forbidden_prefixes; end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:116 + def message(method_name, new_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:128 + def method_definition_macros(macro_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/predicate_name.rb:124 + def predicate_prefixes; end +end + +# Makes sure that rescued exceptions variables are named as +# expected. +# +# The `PreferredName` config option takes a `String`. It represents +# the required name of the variable. Its default is `e`. +# +# NOTE: This cop does not consider nested rescues because it cannot +# guarantee that the variable from the outer rescue is not used within +# the inner rescue (in which case, changing the inner variable would +# shadow the outer variable). +# +# @example PreferredName: e (default) +# # bad +# begin +# # do something +# rescue MyException => exception +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => e +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => _e +# # do something +# end +# @example PreferredName: exception +# # bad +# begin +# # do something +# rescue MyException => e +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => exception +# # do something +# end +# +# # good +# begin +# # do something +# rescue MyException => _exception +# # do something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:61 +class RuboCop::Cop::Naming::RescuedExceptionsVariableName < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:66 + def on_resbody(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:108 + def correct_node(corrector, node, offending_name, preferred_name); end + + # If the exception variable is reassigned, that assignment needs to be corrected. + # Further `lvar` nodes will not be corrected though since they now refer to a + # different variable. + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:126 + def correct_reassignment(corrector, node, offending_name, preferred_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:151 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:93 + def offense_range(resbody); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:135 + def preferred_name(variable_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:157 + def shadowed_variable_name?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:144 + def variable_name(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:98 + def variable_name_matches?(node, name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb:64 +RuboCop::Cop::Naming::RescuedExceptionsVariableName::MSG = T.let(T.unsafe(nil), String) + +# Makes sure that all variables use the configured style, +# snake_case or camelCase, for their names. +# +# @example EnforcedStyle: snake_case (default) +# # bad +# fooBar = 1 +# +# # good +# foo_bar = 1 +# @example EnforcedStyle: camelCase +# # bad +# foo_bar = 1 +# +# # good +# fooBar = 1 +# @example AllowedPatterns: ['_v\d+\z'] +# # good +# :release_v1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:26 +class RuboCop::Cop::Naming::VariableName < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedIdentifiers + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_arg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_blockarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_kwarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_kwoptarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_kwrestarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_lvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_optarg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:37 + def on_restarg(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:33 + def valid_name?(node, name, given_style = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:57 + def message(style); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_name.rb:31 +RuboCop::Cop::Naming::VariableName::MSG = T.let(T.unsafe(nil), String) + +# Makes sure that all numbered variables use the +# configured style, snake_case, normalcase, or non_integer, +# for their numbering. +# +# Additionally, `CheckMethodNames` and `CheckSymbols` configuration options +# can be used to specify whether method names and symbols should be checked. +# Both are enabled by default. +# +# @example AllowedPatterns: ['_v\d+\z'] +# # good +# :some_sym_v1 +# @example EnforcedStyle: snake_case +# # bad +# :some_sym1 +# variable1 = 1 +# +# def some_method1; end +# +# def some_method_1(arg1); end +# +# # good +# :some_sym_1 +# variable_1 = 1 +# +# def some_method_1; end +# +# def some_method_1(arg_1); end +# @example EnforcedStyle: non_integer +# # bad +# :some_sym1 +# :some_sym_1 +# +# variable1 = 1 +# variable_1 = 1 +# +# def some_method1; end +# +# def some_method_1; end +# +# def some_methodone(arg1); end +# def some_methodone(arg_1); end +# +# # good +# :some_symone +# :some_sym_one +# +# variableone = 1 +# variable_one = 1 +# +# def some_methodone; end +# +# def some_method_one; end +# +# def some_methodone(argone); end +# def some_methodone(arg_one); end +# +# # In the following examples, we assume `EnforcedStyle: normalcase` (default). +# @example CheckMethodNames: true (default) +# # bad +# def some_method_1; end +# @example CheckMethodNames: false +# # good +# def some_method_1; end +# @example CheckSymbols: true (default) +# # bad +# :some_sym_1 +# @example CheckSymbols: false +# # good +# :some_sym_1 +# @example AllowedIdentifiers: [capture3] +# # good +# expect(Open3).to receive(:capture3) +# @example EnforcedStyle: normalcase (default) +# # bad +# :some_sym_1 +# variable_1 = 1 +# +# def some_method_1; end +# +# def some_method1(arg_1); end +# +# # good +# :some_sym1 +# variable1 = 1 +# +# def some_method1; end +# +# def some_method1(arg1); end +# +# source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:103 +class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedIdentifiers + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::AllowedPattern + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:114 + def on_arg(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:114 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:126 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:126 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:114 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:114 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:114 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:134 + def on_sym(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:110 + def valid_name?(node, name, given_style = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:143 + def message(style); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/naming/variable_number.rb:108 +RuboCop::Cop::Naming::VariableNumber::MSG = T.let(T.unsafe(nil), String) + +# Some common code shared between `NegatedIf` and +# `NegatedWhile` cops. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/negative_conditional.rb:7 +module RuboCop::Cop::NegativeConditional + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/negative_conditional.rb:18 + def empty_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/negative_conditional.rb:15 + def single_negative?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/negative_conditional.rb:20 + def check_negative_conditional(node, message:, &block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/negative_conditional.rb:10 +RuboCop::Cop::NegativeConditional::MSG = T.let(T.unsafe(nil), String) + +# This module provides a list of methods that are: +# 1. In the NilClass by default +# 2. Added to NilClass by explicitly requiring any standard libraries +# 3. Cop's configuration parameter AllowedMethods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/nil_methods.rb:9 +module RuboCop::Cop::NilMethods + include ::RuboCop::Cop::AllowedMethods + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/nil_methods.rb:14 + def nil_methods; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/nil_methods.rb:18 + def other_stdlib_methods; end +end + +# An offense represents a style violation detected by RuboCop. +# +# source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:6 +class RuboCop::Cop::Offense + include ::Comparable + + # @api private + # @return [Offense] a new instance of Offense + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:84 + def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil)); end + + # Returns `-1`, `0`, or `+1` + # if this offense is less than, equal to, or greater than `other`. + # + # @api public + # @return [Integer] comparison result + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:230 + def <=>(other); end + + # @api public + # @return [Boolean] returns `true` if two offenses contain same attributes + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:211 + def ==(other); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:160 + def column; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:170 + def column_length; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:194 + def column_range; end + + # @api public + # @example + # 'LineLength' + # @return [String] a cop class name without department. + # i.e. type of the violation. + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:51 + def cop_name; end + + # @api public + # @return [Boolean] whether this offense can be automatically corrected via + # autocorrect or a todo. + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:102 + def correctable?; end + + # @api public + # @return [Boolean] whether this offense is automatically corrected via + # autocorrect or a todo. + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:113 + def corrected?; end + + # @api public + # @return [Boolean] whether this offense is automatically disabled via a todo. + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:123 + def corrected_with_todo?; end + + # @api public + # @return [Corrector | nil] the autocorrection for this offense, or `nil` when not available + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:62 + def corrector; end + + # @api public + # @return [Boolean] whether this offense was locally disabled with a + # disable or todo where it occurred. + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:134 + def disabled?; end + + # @api public + # @return [Boolean] returns `true` if two offenses contain same attributes + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:211 + def eql?(other); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:179 + def first_line; end + + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:219 + def hash; end + + # @api public + # @return [Parser::Source::Range] the range of the code that is highlighted + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:142 + def highlighted_area; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:189 + def last_column; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:184 + def last_line; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:155 + def line; end + + # @api public + # @return [Parser::Source::Range] the location where the violation is detected. + # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range Parser::Source::Range + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:28 + def location; end + + # @api public + # @example + # 'Line is too long. [90/80]' + # @return [String] human-readable message + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:39 + def message; end + + # Internally we use column number that start at 0, but when + # outputting column numbers, we want them to start at 1. One + # reason is that editors, such as Emacs, expect this. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:203 + def real_column; end + + # @api public + # @return [RuboCop::Cop::Severity] + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:17 + def severity; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:165 + def source_line; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:54 + def status; end + + # This is just for debugging purpose. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:148 + def to_s; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:10 +RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:81 +RuboCop::Cop::Offense::NO_LOCATION = T.let(T.unsafe(nil), RuboCop::Cop::Offense::PseudoSourceRange) + +# source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 +class RuboCop::Cop::Offense::PseudoSourceRange < ::Struct + # Returns the value of attribute begin_pos + # + # @return [Object] the current value of begin_pos + def begin_pos; end + + # Sets the attribute begin_pos + # + # @param value [Object] the value to set the attribute begin_pos to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 + def begin_pos=(_); end + + # Returns the value of attribute column + # + # @return [Object] the current value of column + def column; end + + # Sets the attribute column + # + # @param value [Object] the value to set the attribute column to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 + def column=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:70 + def column_range; end + + # Returns the value of attribute end_pos + # + # @return [Object] the current value of end_pos + def end_pos; end + + # Sets the attribute end_pos + # + # @param value [Object] the value to set the attribute end_pos to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 + def end_pos=(_); end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def first_line; end + + # Returns the value of attribute column + # + # @return [Object] the current value of column + def last_column; end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def last_line; end + + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:74 + def length; end + + # Returns the value of attribute line + # + # @return [Object] the current value of line + def line; end + + # Sets the attribute line + # + # @param value [Object] the value to set the attribute line to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 + def line=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:74 + def size; end + + # Returns the value of attribute source_line + # + # @return [Object] the current value of source_line + def source_line; end + + # Sets the attribute source_line + # + # @param value [Object] the value to set the attribute source_line to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/offense.rb:64 + def source_line=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Common functionality for cops checking if and unless expressions. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/on_normal_if_unless.rb:6 +module RuboCop::Cop::OnNormalIfUnless + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/on_normal_if_unless.rb:7 + def on_if(node); end +end + +# This autocorrects gem dependency order +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:6 +class RuboCop::Cop::OrderedGemCorrector + extend ::RuboCop::Cop::OrderedGemNode + extend ::RuboCop::Cop::RangeHelp + + class << self + # Returns the value of attribute comments_as_separators. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:11 + def comments_as_separators; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:13 + def correct(processed_source, node, previous_declaration, comments_as_separators); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:11 + def processed_source; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:26 + def declaration_with_comment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/ordered_gem_corrector.rb:36 + def swap_range(corrector, range1, range2); end + end +end + +# Common functionality for Bundler/OrderedGems and +# Gemspec/OrderedDependencies. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:7 +module RuboCop::Cop::OrderedGemNode + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:23 + def case_insensitive_out_of_order?(string_a, string_b); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:27 + def consecutive_lines(previous, current); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:55 + def find_gem_name(gem_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:18 + def gem_canonical_name(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:49 + def gem_name(declaration_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:10 + def get_source_range(node, comments_as_separators); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:32 + def register_offense(previous, current); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/ordered_gem_node.rb:61 + def treat_comments_as_separators; end +end + +# Common functionality for handling parentheses. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/parentheses.rb:6 +module RuboCop::Cop::Parentheses + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/parentheses.rb:9 + def parens_required?(node); end +end + +# This autocorrects parentheses +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:6 +class RuboCop::Cop::ParenthesesCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:12 + def correct(corrector, node); end + + private + + # Add a comma back after the heredoc identifier + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:74 + def add_heredoc_comma(corrector, node); end + + # If the node contains a heredoc, remove the comma too + # It'll be added back in the right place later + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:64 + def extend_range_for_heredoc(node, range); end + + # If removing parentheses leaves a comma on its own line, remove all the whitespace + # preceding it to prevent a syntax error. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:41 + def handle_orphaned_comma(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:80 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:28 + def next_char_is_question_mark?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:32 + def only_closing_paren_before_comma?(node); end + + # Get a range for the closing parenthesis and all whitespace to the left of it + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:51 + def parens_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/parentheses_corrector.rb:24 + def ternary_condition?(node); end + end +end + +# Common functionality for handling percent arrays. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:6 +module RuboCop::Cop::PercentArray + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:26 + def allowed_bracket_array?(node); end + + # @param node [RuboCop::AST::ArrayNode] + # @param elements [Array<String>] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:83 + def build_bracketed_array_with_appropriate_whitespace(elements:, node:); end + + # @param preferred_array_code [String] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:56 + def build_message_for_bracketed_array(preferred_array_code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:67 + def check_bracketed_array(node, literal_prefix); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:36 + def check_percent_array(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:31 + def comments_in_array?(node); end + + # Override to determine values that are invalid in a percent array + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:22 + def invalid_percent_array_contents?(_node); end + + # Ruby does not allow percent arrays in an ambiguous block context. + # + # @example + # + # foo %i[bar baz] { qux } + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:14 + def invalid_percent_array_context?(node); end + + # Provides whitespace between elements for building a bracketed array. + # %w[ a b c ] + # ^^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:98 + def whitespace_between(node); end + + # Provides leading whitespace for building a bracketed array. + # %w[ a b c ] + # ^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:113 + def whitespace_leading(node); end + + # Provides trailing whitespace for building a bracketed array. + # %w[ a b c ] + # ^^^^ + # + # @param node [RuboCop::AST::ArrayNode] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_array.rb:122 + def whitespace_trailing(node); end +end + +# Common functionality for handling percent literals. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_literal.rb:6 +module RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_literal.rb:23 + def begin_source(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_literal.rb:11 + def percent_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_literal.rb:17 + def process(node, *types); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/percent_literal.rb:27 + def type(node); end +end + +# This autocorrects percent literals +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:6 +class RuboCop::Cop::PercentLiteralCorrector + include ::RuboCop::PathUtil + include ::RuboCop::Cop::Util + + # @return [PercentLiteralCorrector] a new instance of PercentLiteralCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:11 + def initialize(config, preferred_delimiters); end + + # Returns the value of attribute config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:9 + def config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:16 + def correct(corrector, node, char); end + + # Returns the value of attribute preferred_delimiters. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:9 + def preferred_delimiters; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:46 + def autocorrect_multiline_words(node, escape, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:52 + def autocorrect_words(node, escape, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:34 + def delimiters_for(type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:100 + def end_content(source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:30 + def escape_words?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:78 + def first_line?(node, previous_line_num); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:89 + def fix_escaped_content(word_node, escape, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:69 + def line_breaks(node, source, previous_line_num, base_line_num, node_indx); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:38 + def new_contents(node, escape, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:82 + def process_lines(node, previous_line_num, base_line_num, source_in_lines); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:58 + def process_multiline_words(node, escape, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:96 + def substitute_escaped_delimiters(content, delimiters); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/percent_literal_corrector.rb:26 + def wrap_contents(corrector, node, contents, char, delimiters); end +end + +# Common functionality for checking whether an AST node/token is aligned +# with something on a preceding or following line +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:7 +module RuboCop::Cop::PrecedingFollowingAlignment + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:95 + def aligned_assignment?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:91 + def aligned_char?(range, line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:70 + def aligned_comment_lines; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:107 + def aligned_identical?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:83 + def aligned_operator?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:77 + def aligned_token?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:34 + def aligned_with_adjacent_line?(range, predicate); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:52 + def aligned_with_any_line?(line_ranges, range, indent = T.unsafe(nil), &predicate); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:42 + def aligned_with_any_line_range?(line_ranges, range, &predicate); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:100 + def aligned_with_append_operator?(range, line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:111 + def aligned_with_assignment(token, line_range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:56 + def aligned_with_line?(line_nos, range, indent = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:18 + def aligned_with_operator?(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:22 + def aligned_with_preceding_assignment(token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:14 + def aligned_with_something?(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:28 + def aligned_with_subsequent_assignment(token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:87 + def aligned_words?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:10 + def allow_for_alignment?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:129 + def assignment_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:133 + def assignment_tokens; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:149 + def relevant_assignment_lines(line_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preceding_following_alignment.rb:176 + def remove_optarg_equals(asgn_tokens, processed_source); end +end + +# Common functionality for handling percent literal delimiters. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:6 +class RuboCop::Cop::PreferredDelimiters + # @return [PreferredDelimiters] a new instance of PreferredDelimiters + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:11 + def initialize(type, config, preferred_delimiters); end + + # Returns the value of attribute config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:7 + def config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:17 + def delimiters; end + + # Returns the value of attribute type. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:7 + def type; end + + private + + # @raise [ArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:23 + def ensure_valid_preferred_delimiters; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:30 + def preferred_delimiters; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:45 + def preferred_delimiters_config; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/preferred_delimiters.rb:9 +RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Array) + +# This autocorrects punctuation +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/punctuation_corrector.rb:6 +class RuboCop::Cop::PunctuationCorrector + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/punctuation_corrector.rb:12 + def add_space(corrector, token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/punctuation_corrector.rb:8 + def remove_space(corrector, space_before); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/punctuation_corrector.rb:16 + def swap_comma(corrector, range); end + end +end + +# Methods that calculate and return Parser::Source::Ranges +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:6 +module RuboCop::Cop::RangeHelp + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:82 + def column_offset_between(base_range, range); end + + # A range containing only the contents of a literal with delimiters (e.g. in + # `%i{1 2 3}` this will be the range covering `1 2 3` only). + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:32 + def contents_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:100 + def directions(side); end + + # Returns the column attribute of the range, except if the range is on + # the first line and there's a byte order mark at the beginning of that + # line, in which case 1 is subtracted from the column value. This gives + # the column as it appears when viewing the file in an editor. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:92 + def effective_column(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:109 + def final_pos(src, pos, increment, continuations, newlines, whitespace); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:117 + def move_pos(src, pos, step, condition, regexp); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:123 + def move_pos_str(src, pos, step, condition, needle); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:36 + def range_between(start_pos, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:73 + def range_by_whole_lines(range, include_final_newline: T.unsafe(nil), buffer: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:40 + def range_with_surrounding_comma(range, side = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:55 + def range_with_surrounding_space(range_positional = T.unsafe(nil), range: T.unsafe(nil), side: T.unsafe(nil), newlines: T.unsafe(nil), whitespace: T.unsafe(nil), continuations: T.unsafe(nil), buffer: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:11 + def source_range(source_buffer, line_number, column, length = T.unsafe(nil)); end +end + +# The Unicode codepoint +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:9 +RuboCop::Cop::RangeHelp::BYTE_ORDER_MARK = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/range_help.rb:54 +module RuboCop::Cop::RangeHelp::NOT_GIVEN; end + +# Common functionality for handling Rational literals. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/rational_literal.rb:6 +module RuboCop::Cop::RationalLiteral + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/rational_literal.rb:12 + def rational_literal?(param0 = T.unsafe(nil)); end +end + +# Registry that tracks all cops by their badge and department. +# +# source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:19 +class RuboCop::Cop::Registry + include ::Enumerable + + # @return [Registry] a new instance of Registry + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:24 + def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:183 + def ==(other); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:67 + def contains_cop_matching?(names); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:142 + def cops; end + + # @return [Boolean] Checks if given name is department + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:63 + def department?(name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:117 + def department_missing?(badge, name); end + + # @return [Array<Symbol>] list of departments for current cops. + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:42 + def departments; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:37 + def dismiss(cop); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:198 + def each(&block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:152 + def enabled(config, only = T.unsafe(nil), only_safe: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:156 + def enabled?(cop, config, only_safe); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:168 + def enabled_pending_cop?(cop_cfg, config); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:33 + def enlist(cop); end + + # @param cop_name [String] + # @return [Class, nil] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:204 + def find_by_cop_name(cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:208 + def freeze; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:147 + def length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:175 + def names; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:179 + def names_for_department(department); end + + # Returns the value of attribute options. + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:22 + def options; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:121 + def print_warning(name, path); end + + # Convert a user provided cop name into a properly namespaced name + # + # @example gives back a correctly qualified cop name + # + # cops = RuboCop::Cop::Cop.all + # cops. + # qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine' + # @example fixes incorrect namespaces + # + # cops = RuboCop::Cop::Cop.all + # cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine' + # @example namespaces bare cop identifiers + # + # cops = RuboCop::Cop::Cop.all + # cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine' + # @example passes back unrecognized cop names + # + # cops = RuboCop::Cop::Cop.all + # cops.qualified_cop_name('NotACop') # => 'NotACop' + # @note Emits a warning if the provided name has an incorrect namespace + # @param name [String] Cop name extracted from config + # @param path [String, nil] Path of file that `name` was extracted from + # @raise [AmbiguousCopName] if a bare identifier with two possible namespaces is provided + # @return [String] Qualified cop name + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:103 + def qualified_cop_name(name, path, warn: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:194 + def select(&block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:187 + def sort!; end + + # @return [Hash{String => Array<Class>}] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:137 + def to_h; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:129 + def unqualified_cop_names; end + + # @return [Registry] Cops for that specific department. + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:48 + def with_department(department); end + + # @return [Registry] Cops not for a specific department. + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:54 + def without_department(department); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:248 + def clear_enrollment_queue; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:244 + def initialize_copy(reg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:264 + def qualify_badge(badge); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:281 + def registered?(badge); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:271 + def resolve_badge(given_badge, real_badge, source_path); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:260 + def with(cops); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:220 + def all; end + + # Returns the value of attribute global. + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:217 + def global; end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:224 + def qualified_cop_name(name, origin); end + + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:238 + def reset!; end + + # Changes momentarily the global registry + # Intended for testing purposes + # + # source://rubocop-1.35.1/lib/rubocop/cop/registry.rb:230 + def with_temporary_global(temp_global = T.unsafe(nil)); end + end +end + +# Ensure a require statement is present for a standard library determined +# by variable library_name +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:7 +module RuboCop::Cop::RequireLibrary + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:10 + def ensure_required(corrector, node, library_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:31 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:22 + def remove_subsequent_requires(corrector, node, library_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:49 + def require_any_library?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:54 + def require_library_name?(param0 = T.unsafe(nil), param1); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/require_library.rb:42 + def on_new_investigation; end +end + +# This class ensures a require statement is present for a standard library +# determined by the variable library_name +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/require_library_corrector.rb:7 +class RuboCop::Cop::RequireLibraryCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/require_library_corrector.rb:11 + def correct(corrector, node, library_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/require_library_corrector.rb:17 + def require_statement(library_name); end + end +end + +# Common functionality for checking `rescue` nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/rescue_node.rb:6 +module RuboCop::Cop::RescueNode + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/rescue_node.rb:7 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/rescue_node.rb:13 + def rescue_modifier?(node); end + + # @deprecated Use ResbodyNode#exceptions instead + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/rescue_node.rb:18 + def rescued_exceptions(resbody); end +end + +# Common functionality for safe assignment. By safe assignment we mean +# putting parentheses around an assignment to indicate "I know I'm using an +# assignment as a condition. It's not a mistake." +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/safe_assignment.rb:8 +module RuboCop::Cop::SafeAssignment + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/safe_assignment.rb:14 + def empty_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/safe_assignment.rb:20 + def safe_assignment?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/safe_assignment.rb:17 + def setter_method?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/safe_assignment.rb:22 + def safe_assignment_allowed?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:5 +module RuboCop::Cop::Security; end + +# Checks for implementations of the `hash` method which combine +# values using custom logic instead of delegating to `Array#hash`. +# +# Manually combining hashes is error prone and hard to follow, especially +# when there are many values. Poor implementations may also introduce +# performance or security concerns if they are prone to collisions. +# Delegating to `Array#hash` is clearer, faster, and safer. +# +# @example +# +# # bad +# def hash +# @foo ^ @bar +# end +# +# # good +# def hash +# [@foo, @bar].hash +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:29 +class RuboCop::Cop::Security::CompoundHash < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:57 + def bad_hash_combinator?(param0 = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:74 + def contained_in_hash_method?(node, &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:41 + def dynamic_hash_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:36 + def hash_method_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:62 + def monuple_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:86 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:86 + def on_send(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:80 + def outer_bad_hash_combinator?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:67 + def redundant_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:50 + def static_hash_method_definition?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:30 +RuboCop::Cop::Security::CompoundHash::COMBINATOR_IN_HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:31 +RuboCop::Cop::Security::CompoundHash::MONUPLE_HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/compound_hash.rb:33 +RuboCop::Cop::Security::CompoundHash::REDUNDANT_HASH_MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of `Kernel#eval` and `Binding#eval`. +# +# @example +# +# # bad +# +# eval(something) +# binding.eval(something) +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/eval.rb:14 +class RuboCop::Cop::Security::Eval < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/security/eval.rb:19 + def eval?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/eval.rb:23 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/eval.rb:15 +RuboCop::Cop::Security::Eval::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/eval.rb:16 +RuboCop::Cop::Security::Eval::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`, +# `IO.foreach`, and `IO.readlines`. +# +# If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class, +# a subprocess is created in the same way as `Kernel#open`, and its output is returned. +# `Kernel#open` may allow unintentional command injection, which is the reason these +# `IO` methods are a security risk. +# Consider to use `File.read` to disable the behavior of subprocess invocation. +# +# @example +# +# # bad +# IO.read(path) +# IO.read('path') +# +# # good +# File.read(path) +# File.read('path') +# IO.read('| command') # Allow intentional command invocation. +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/io_methods.rb:30 +class RuboCop::Cop::Security::IoMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/security/io_methods.rb:36 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/io_methods.rb:33 +RuboCop::Cop::Security::IoMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/io_methods.rb:34 +RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of JSON class methods which have potential +# security issues. +# +# @example +# # bad +# JSON.load("{}") +# JSON.restore("{}") +# +# # good +# JSON.parse("{}") +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/json_load.rb:26 +class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/security/json_load.rb:33 + def json_load(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/json_load.rb:37 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/json_load.rb:29 +RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/json_load.rb:30 +RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of Marshal class methods which have +# potential security issues leading to remote code execution when +# loading from an untrusted source. +# +# @example +# # bad +# Marshal.load("{}") +# Marshal.restore("{}") +# +# # good +# Marshal.dump("{}") +# +# # okish - deep copy hack +# Marshal.load(Marshal.dump({})) +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/marshal_load.rb:21 +class RuboCop::Cop::Security::MarshalLoad < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/security/marshal_load.rb:26 + def marshal_load(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/marshal_load.rb:31 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/marshal_load.rb:22 +RuboCop::Cop::Security::MarshalLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/marshal_load.rb:23 +RuboCop::Cop::Security::MarshalLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of `Kernel#open` and `URI.open` with dynamic +# data. +# +# `Kernel#open` and `URI.open` enable not only file access but also process +# invocation by prefixing a pipe symbol (e.g., `open("| ls")`). +# So, it may lead to a serious security risk by using variable input to +# the argument of `Kernel#open` and `URI.open`. It would be better to use +# `File.open`, `IO.popen` or `URI.parse#open` explicitly. +# +# NOTE: `open` and `URI.open` with literal strings are not flagged by this +# cop. +# +# @example +# # bad +# open(something) +# open("| #{something}") +# URI.open(something) +# +# # good +# File.open(something) +# IO.popen(something) +# URI.parse(something).open +# +# # good (literal strings) +# open("foo.text") +# open("| foo") +# URI.open("http://example.com") +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:37 +class RuboCop::Cop::Security::Open < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:46 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:42 + def open?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:75 + def composite_string?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:83 + def concatenated_string?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:79 + def interpolated_string?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:57 + def safe?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:67 + def safe_argument?(argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:71 + def simple_string?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:38 +RuboCop::Cop::Security::Open::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/open.rb:39 +RuboCop::Cop::Security::Open::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of YAML class methods which have +# potential security issues leading to remote code execution when +# loading from an untrusted source. +# +# NOTE: Ruby 3.1+ (Psych 4) uses `Psych.load` as `Psych.safe_load` by default. +# +# @example +# # bad +# YAML.load("--- !ruby/object:Foo {}") # Psych 3 is unsafe by default +# +# # good +# YAML.safe_load("--- !ruby/object:Foo {}", [Foo]) # Ruby 2.5 (Psych 3) +# YAML.safe_load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.0- (Psych 3) +# YAML.load("--- !ruby/object:Foo {}", permitted_classes: [Foo]) # Ruby 3.1+ (Psych 4) +# YAML.dump(foo) +# +# source://rubocop-1.35.1/lib/rubocop/cop/security/yaml_load.rb:26 +class RuboCop::Cop::Security::YAMLLoad < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/security/yaml_load.rb:37 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/security/yaml_load.rb:33 + def yaml_load(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/security/yaml_load.rb:29 +RuboCop::Cop::Security::YAMLLoad::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/security/yaml_load.rb:30 +RuboCop::Cop::Security::YAMLLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Severity class is simple value object about severity +# +# source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:6 +class RuboCop::Cop::Severity + include ::Comparable + + # @api private + # @raise [ArgumentError] + # @return [Severity] a new instance of Severity + # + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:30 + def initialize(name_or_code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:62 + def <=>(other); end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:50 + def ==(other); end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:42 + def code; end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:58 + def hash; end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:46 + def level; end + + # @api public + # @return [Symbol] severity. + # any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`. + # + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:22 + def name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:38 + def to_s; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:24 + def name_from_code(code); end + end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:12 +RuboCop::Cop::Severity::CODE_TABLE = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/severity.rb:9 +RuboCop::Cop::Severity::NAMES = T.let(T.unsafe(nil), Array) + +# Common functionality for cops checking for missing space after +# punctuation. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:7 +module RuboCop::Cop::SpaceAfterPunctuation + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:10 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:38 + def allowed_type?(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:20 + def each_missing_space(tokens); end + + # The normal offset, i.e., the distance from the punctuation + # token where a space should be, is 1. + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:49 + def offset; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:42 + def space_forbidden_before_rcurly?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:30 + def space_missing?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:34 + def space_required_before?(token); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_after_punctuation.rb:8 +RuboCop::Cop::SpaceAfterPunctuation::MSG = T.let(T.unsafe(nil), String) + +# Common functionality for cops checking for space before +# punctuation. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:7 +module RuboCop::Cop::SpaceBeforePunctuation + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:12 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:22 + def each_missing_space(tokens); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:34 + def space_missing?(token1, token2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:38 + def space_required_after?(token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:42 + def space_required_after_lcurly?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/space_before_punctuation.rb:10 +RuboCop::Cop::SpaceBeforePunctuation::MSG = T.let(T.unsafe(nil), String) + +# This autocorrects whitespace +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/space_corrector.rb:6 +class RuboCop::Cop::SpaceCorrector + extend ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::SurroundingSpace + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/space_corrector.rb:36 + def add_space(processed_source, corrector, left_token, right_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/space_corrector.rb:12 + def empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/space_corrector.rb:10 + def processed_source; end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/space_corrector.rb:24 + def remove_space(processed_source, corrector, left_token, right_token); end + end +end + +# Common functionality for modifier cops. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:6 +module RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::LineLengthHelp + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:64 + def code_after(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:88 + def comment_disables_cop?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:56 + def first_line_comment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:43 + def length_in_modifier_form(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:82 + def max_line_length; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:37 + def modifier_fits_on_single_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:26 + def non_eligible_body?(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:33 + def non_eligible_condition?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:19 + def non_eligible_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:70 + def parenthesize?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:11 + def single_line_as_modifier?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/statement_modifier.rb:50 + def to_modifier_form(node); end +end + +# Classes that include this module just implement functions to determine +# what is an offense and how to do autocorrection. They get help with +# adding offenses for the faulty string nodes, and with filtering out +# nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_help.rb:9 +module RuboCop::Cop::StringHelp + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_help.rb:26 + def on_regexp(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_help.rb:10 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_help.rb:32 + def inside_interpolation?(node); end +end + +# This autocorrects string literals +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/string_literal_corrector.rb:6 +class RuboCop::Cop::StringLiteralCorrector + extend ::RuboCop::PathUtil + extend ::RuboCop::Cop::Util + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/string_literal_corrector.rb:10 + def correct(corrector, node, style); end + end +end + +# Common functionality for cops checking single/double quotes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_literals_help.rb:6 +module RuboCop::Cop::StringLiteralsHelp + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/string_literals_help.rb:9 + def wrong_quotes?(src_or_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:5 +module RuboCop::Cop::Style; end + +# Access modifiers should be declared to apply to a group of methods +# or inline before each method, depending on configuration. +# EnforcedStyle config covers only method definitions. +# Applications of visibility methods to symbols can be controlled +# using AllowModifiersOnSymbols config. +# +# @example EnforcedStyle: group (default) +# # bad +# class Foo +# +# private def bar; end +# private def baz; end +# +# end +# +# # good +# class Foo +# +# private +# +# def bar; end +# def baz; end +# +# end +# @example EnforcedStyle: inline +# # bad +# class Foo +# +# private +# +# def bar; end +# def baz; end +# +# end +# +# # good +# class Foo +# +# private def bar; end +# private def baz; end +# +# end +# @example AllowModifiersOnSymbols: true (default) +# # good +# class Foo +# +# private :bar, :baz +# +# end +# @example AllowModifiersOnSymbols: false +# # bad +# class Foo +# +# private :bar, :baz +# +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:65 +class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:81 + def access_modifier_with_symbol?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:85 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:116 + def access_modifier_is_inlined?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:120 + def access_modifier_is_not_inlined?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:99 + def allow_modifiers_on_symbols?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:108 + def group_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:112 + def inline_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:124 + def message(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:103 + def offense?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:68 +RuboCop::Cop::Style::AccessModifierDeclarations::GROUP_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:73 +RuboCop::Cop::Style::AccessModifierDeclarations::INLINE_STYLE_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/access_modifier_declarations.rb:78 +RuboCop::Cop::Style::AccessModifierDeclarations::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for grouping of accessors in `class` and `module` bodies. +# By default it enforces accessors to be placed in grouped declarations, +# but it can be configured to enforce separating them in multiple declarations. +# +# NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style +# or disabling this cop. +# +# @example EnforcedStyle: grouped (default) +# # bad +# class Foo +# attr_reader :bar +# attr_reader :baz +# end +# +# # good +# class Foo +# attr_reader :bar, :baz +# end +# @example EnforcedStyle: separated +# # bad +# class Foo +# attr_reader :bar, :baz +# end +# +# # good +# class Foo +# attr_reader :bar +# attr_reader :baz +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:37 +class RuboCop::Cop::Style::AccessorGrouping < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::VisibilityHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:48 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:48 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:48 + def on_sclass(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:96 + def accessor?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:71 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:60 + def check(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:84 + def class_send_elements(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:131 + def group_accessors(node, accessors); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:100 + def grouped_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:117 + def message(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:122 + def preferred_accessors(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:80 + def previous_line_comment?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:137 + def separate_accessors(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:104 + def separated_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:108 + def sibling_accessors(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:46 +RuboCop::Cop::Style::AccessorGrouping::ACCESSOR_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:43 +RuboCop::Cop::Style::AccessorGrouping::GROUPED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/accessor_grouping.rb:44 +RuboCop::Cop::Style::AccessorGrouping::SEPARATED_MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of either `#alias` or `#alias_method` +# depending on configuration. +# It also flags uses of `alias :symbol` rather than `alias bareword`. +# +# @example EnforcedStyle: prefer_alias (default) +# # bad +# alias_method :bar, :foo +# alias :bar :foo +# +# # good +# alias bar foo +# @example EnforcedStyle: prefer_alias_method +# # bad +# alias :bar :foo +# alias bar foo +# +# # good +# alias_method :bar, :foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:25 +class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:142 + def identifier(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:45 + def on_alias(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:35 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:77 + def add_offense_for_args(node, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:69 + def alias_keyword_possible?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:73 + def alias_method_possible?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:59 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:116 + def bareword?(sym_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:120 + def correct_alias_method_to_alias(corrector, send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:127 + def correct_alias_to_alias_method(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:136 + def correct_alias_with_symbol_args(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:105 + def lexical_scope_type(node); end + + # In this expression, will `self` be the same as the innermost enclosing + # class or module block (:lexical)? Or will it be something else + # (:dynamic)? If we're in an instance_eval block, return that. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:88 + def scope_type(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:29 +RuboCop::Cop::Style::Alias::MSG_ALIAS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:30 +RuboCop::Cop::Style::Alias::MSG_ALIAS_METHOD = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:31 +RuboCop::Cop::Style::Alias::MSG_SYMBOL_ARGS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/alias.rb:33 +RuboCop::Cop::Style::Alias::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `and` and `or`, and suggests using `&&` and +# `||` instead. It can be configured to check only in conditions or in +# all contexts. +# +# @example EnforcedStyle: conditionals (default) +# # bad +# if foo and bar +# end +# +# # good +# foo.save && return +# +# # good +# foo.save and return +# +# # good +# if foo && bar +# end +# @example EnforcedStyle: always +# # bad +# foo.save and return +# +# # bad +# if foo and bar +# end +# +# # good +# foo.save && return +# +# # good +# if foo && bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:44 +class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:51 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:56 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:51 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:56 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:56 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:56 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:56 + def on_while_post(node); end + + private + + # ! is a special case: + # 'x and !obj.method arg' can be autocorrected if we + # recurse down a level and add parens to 'obj.method arg' + # however, 'not x' also parses as (send x :!) + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:117 + def correct_not(node, receiver, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:129 + def correct_other(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:95 + def correct_send(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:108 + def correct_setter(node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:143 + def correctable_send?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:135 + def keep_operator_precedence(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:91 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:85 + def on_conditionals(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:66 + def process_logical_operator(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:147 + def whitespace_before_arg(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/and_or.rb:49 +RuboCop::Cop::Style::AndOr::MSG = T.let(T.unsafe(nil), String) + +# In Ruby 2.7, arguments forwarding has been added. +# +# This cop identifies places where `do_something(*args, &block)` +# can be replaced by `do_something(...)`. +# +# @example +# # bad +# def foo(*args, &block) +# bar(*args, &block) +# end +# +# # bad +# def foo(*args, **kwargs, &block) +# bar(*args, **kwargs, &block) +# end +# +# # good +# def foo(...) +# bar(...) +# end +# @example AllowOnlyRestArgument: true (default) +# # good +# def foo(*args) +# bar(*args) +# end +# +# def foo(**kwargs) +# bar(**kwargs) +# end +# @example AllowOnlyRestArgument: false +# # bad +# # The following code can replace the arguments with `...`, +# # but it will change the behavior. Because `...` forwards block also. +# def foo(*args) +# bar(*args) +# end +# +# def foo(**kwargs) +# bar(**kwargs) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:49 +class RuboCop::Cop::Style::ArgumentsForwarding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:72 + def forwarding_method_arguments?(param0 = T.unsafe(nil), param1, param2, param3); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:84 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:84 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:64 + def only_rest_arguments?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:59 + def use_rest_arguments?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:115 + def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:148 + def allow_only_rest_arguments?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:142 + def arguments_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:102 + def extract_argument_names_from(args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:109 + def forwarding_method?(node, rest_arg, kwargs, block_arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:124 + def register_offense_to_forwarding_method_arguments(forwarding_method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:133 + def register_offense_to_method_definition_arguments(method_definition); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/arguments_forwarding.rb:56 +RuboCop::Cop::Style::ArgumentsForwarding::MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of `Array()` instead of explicit `Array` check or `[*var]`. +# +# The cop is disabled by default due to safety concerns. +# +# @example +# # bad +# paths = [paths] unless paths.is_a?(Array) +# paths.each { |path| do_something(path) } +# +# # bad (always creates a new Array instance) +# [*paths].each { |path| do_something(path) } +# +# # good (and a bit more readable) +# Array(paths).each { |path| do_something(path) } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:41 +class RuboCop::Cop::Style::ArrayCoercion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:48 + def array_splat?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:63 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:74 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:53 + def unless_array?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:45 +RuboCop::Cop::Style::ArrayCoercion::CHECK_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_coercion.rb:44 +RuboCop::Cop::Style::ArrayCoercion::SPLAT_MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of "*" as a substitute for _join_. +# +# Not all cases can reliably checked, due to Ruby's dynamic +# types, so we consider only cases when the first argument is an +# array literal or the second is a string literal. +# +# @example +# +# # bad +# %w(foo bar baz) * "," +# +# # good +# %w(foo bar baz).join(",") +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_join.rb:20 +class RuboCop::Cop::Style::ArrayJoin < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_join.rb:27 + def join_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/array_join.rb:29 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_join.rb:23 +RuboCop::Cop::Style::ArrayJoin::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/array_join.rb:24 +RuboCop::Cop::Style::ArrayJoin::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:16 +class RuboCop::Cop::Style::AsciiComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:21 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:51 + def allowed_non_ascii_chars; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:42 + def first_non_ascii_chars(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:32 + def first_offense_range(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:46 + def only_allowed_non_ascii_chars?(string); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ascii_comments.rb:19 +RuboCop::Cop::Style::AsciiComments::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of Module#attr. +# +# @example +# # bad - creates a single attribute accessor (deprecated in Ruby 1.9) +# attr :something, true +# attr :one, :two, :three # behaves as attr_reader +# +# # good +# attr_accessor :something +# attr_reader :one, :two, :three +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:17 +class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:64 + def class_eval?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:24 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:37 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:49 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:53 + def replacement_method(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:21 +RuboCop::Cop::Style::Attr::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/attr.rb:22 +RuboCop::Cop::Style::Attr::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for cases when you could use a block +# accepting version of a method that does automatic +# resource cleanup. +# +# @example +# +# # bad +# f = File.open('file') +# +# # good +# File.open('file') do |f| +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:19 +class RuboCop::Cop::Style::AutoResourceCleanup < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:26 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:41 + def cleanup?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:20 +RuboCop::Cop::Style::AutoResourceCleanup::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:24 +RuboCop::Cop::Style::AutoResourceCleanup::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/auto_resource_cleanup.rb:22 +RuboCop::Cop::Style::AutoResourceCleanup::TARGET_METHODS = T.let(T.unsafe(nil), Hash) + +# Checks if usage of %() or %Q() matches configuration. +# +# @example EnforcedStyle: bare_percent (default) +# # bad +# %Q(He said: "#{greeting}") +# %q{She said: 'Hi'} +# +# # good +# %(He said: "#{greeting}") +# %{She said: 'Hi'} +# @example EnforcedStyle: percent_q +# # bad +# %|He said: "#{greeting}"| +# %/She said: 'Hi'/ +# +# # good +# %Q|He said: "#{greeting}"| +# %q/She said: 'Hi'/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:26 +class RuboCop::Cop::Style::BarePercentLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:32 + def on_dstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:36 + def on_str(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:63 + def add_offense_for_wrong_style(node, good, bad); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:42 + def check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:59 + def requires_bare_percent?(source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:55 + def requires_percent_q?(source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/bare_percent_literals.rb:30 +RuboCop::Cop::Style::BarePercentLiterals::MSG = T.let(T.unsafe(nil), String) + +# This cop checks for BEGIN blocks. +# +# @example +# # bad +# BEGIN { test } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/begin_block.rb:13 +class RuboCop::Cop::Style::BeginBlock < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/begin_block.rb:16 + def on_preexe(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/begin_block.rb:14 +RuboCop::Cop::Style::BeginBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where `attr_reader` and `attr_writer` +# for the same method can be combined into single `attr_accessor`. +# +# @example +# # bad +# class Foo +# attr_reader :bar +# attr_writer :bar +# end +# +# # good +# class Foo +# attr_accessor :bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:21 +class RuboCop::Cop::Style::BisectedAttrAccessor < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:55 + def after_class(class_node); end + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:55 + def after_module(class_node); end + + # Each offending macro is captured and registered in `on_class` but correction + # happens in `after_class` because a macro might have multiple attributes + # rewritten from it + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:55 + def after_sclass(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:33 + def on_class(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:33 + def on_module(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:29 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:33 + def on_sclass(class_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:102 + def correct_reader(corrector, macro, node, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:114 + def correct_writer(corrector, macro, node, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:91 + def find_bisection(macros); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:74 + def find_macros(class_def); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:98 + def register_offense(attr); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor.rb:27 +RuboCop::Cop::Style::BisectedAttrAccessor::MSG = T.let(T.unsafe(nil), String) + +# Representation of an `attr_reader`, `attr_writer` or `attr` macro +# for use by `Style/BisectedAttrAccessor`. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:10 +class RuboCop::Cop::Style::BisectedAttrAccessor::Macro + include ::RuboCop::Cop::VisibilityHelp + + # @api private + # @return [Macro] a new instance of Macro + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:19 + def initialize(node); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:49 + def all_bisected?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:29 + def attr_names; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:13 + def attrs; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:25 + def bisect(*names); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:33 + def bisected_names; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:13 + def bisection; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:13 + def node; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:41 + def reader?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:53 + def rest; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:37 + def visibility; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:45 + def writer?; end + + class << self + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/bisected_attr_accessor/macro.rb:15 + def macro?(node); end + end +end + +# Looks for uses of block comments (=begin...=end). +# +# @example +# # bad +# =begin +# Multiple lines +# of comments... +# =end +# +# # good +# # Multiple lines +# # of comments... +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:19 +class RuboCop::Cop::Style::BlockComments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:27 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:56 + def eq_end_part(comment, expr); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:48 + def parts(comment); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:24 +RuboCop::Cop::Style::BlockComments::BEGIN_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:25 +RuboCop::Cop::Style::BlockComments::END_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_comments.rb:23 +RuboCop::Cop::Style::BlockComments::MSG = T.let(T.unsafe(nil), String) + +# Check for uses of braces or do/end around single line or +# multi-line blocks. +# +# Methods that can be either procedural or functional and cannot be +# categorised from their usage alone is ignored. +# `lambda`, `proc`, and `it` are their defaults. +# Additional methods can be added to the `AllowedMethods`. +# +# @example AllowedPatterns: [/map/] +# +# # good +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# @example EnforcedStyle: semantic +# # Prefer `do...end` over `{...}` for procedural blocks. +# +# # return value is used/assigned +# # bad +# foo = map do |x| +# x +# end +# puts (map do |x| +# x +# end) +# +# # return value is not used out of scope +# # good +# map do |x| +# x +# end +# +# # Prefer `{...}` over `do...end` for functional blocks. +# +# # return value is not used out of scope +# # bad +# each { |x| +# x +# } +# +# # return value is used/assigned +# # good +# foo = map { |x| +# x +# } +# map { |x| +# x +# }.inspect +# +# # The AllowBracesOnProceduralOneLiners option is allowed unless the +# # EnforcedStyle is set to `semantic`. If so: +# +# # If the AllowBracesOnProceduralOneLiners option is unspecified, or +# # set to `false` or any other falsey value, then semantic purity is +# # maintained, so one-line procedural blocks must use do-end, not +# # braces. +# +# # bad +# collection.each { |element| puts element } +# +# # good +# collection.each do |element| puts element end +# +# # If the AllowBracesOnProceduralOneLiners option is set to `true`, or +# # any other truthy value, then one-line procedural blocks may use +# # either style. (There is no setting for requiring braces on them.) +# +# # good +# collection.each { |element| puts element } +# +# # also good +# collection.each do |element| puts element end +# @example EnforcedStyle: braces_for_chaining +# # bad +# words.each do |word| +# word.flip.flop +# end.join("-") +# +# # good +# words.each { |word| +# word.flip.flop +# }.join("-") +# @example EnforcedStyle: always_braces +# # bad +# words.each do |word| +# word.flip.flop +# end +# +# # good +# words.each { |word| +# word.flip.flop +# } +# @example BracesRequiredMethods: ['sig'] +# +# # Methods listed in the BracesRequiredMethods list, such as 'sig' +# # in this example, will require `{...}` braces. This option takes +# # precedence over all other configurations except AllowedMethods. +# +# # bad +# sig do +# params( +# foo: string, +# ).void +# end +# def bar(foo) +# puts foo +# end +# +# # good +# sig { +# params( +# foo: string, +# ).void +# } +# def bar(foo) +# puts foo +# end +# @example AllowedMethods: ['lambda', 'proc', 'it' ] (default) +# +# # good +# foo = lambda do |x| +# puts "Hello, #{x}" +# end +# +# foo = lambda do |x| +# x * 100 +# end +# @example AllowedPatterns: [] (default) +# +# # bad +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# @example EnforcedStyle: line_count_based (default) +# # bad - single line block +# items.each do |item| item / 5 end +# +# # good - single line block +# items.each { |item| item / 5 } +# +# # bad - multi-line block +# things.map { |thing| +# something = thing.some_method +# process(something) +# } +# +# # good - multi-line block +# things.map do |thing| +# something = thing.some_method +# process(something) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:168 +class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:194 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:194 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:179 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:443 + def array_or_range?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:208 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:447 + def begin_required?(block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:236 + def braces_for_chaining_message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:384 + def braces_for_chaining_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:248 + def braces_required_message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:361 + def braces_required_method?(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:365 + def braces_required_methods; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:394 + def braces_style?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:439 + def conditional?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:398 + def correction_would_break_code?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:309 + def end_of_chain(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:408 + def functional_block?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:404 + def functional_method?(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:320 + def get_blocks(node, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:369 + def line_count_based_block_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:218 + def line_count_based_message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:252 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:300 + def move_comment_before_block(corrector, comment, block_node, closing_brace); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:416 + def procedural_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:412 + def procedural_oneliners_may_have_braces?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:338 + def proper_block_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:263 + def replace_braces_with_do_end(corrector, loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:279 + def replace_do_end_with_braces(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:432 + def return_value_of_scope?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:420 + def return_value_used?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:373 + def semantic_block_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:226 + def semantic_message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:349 + def special_method?(method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:355 + def special_method_proper_block_style?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:296 + def whitespace_after?(range, length = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:292 + def whitespace_before?(range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:316 + def with_block?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:175 +RuboCop::Cop::Style::BlockDelimiters::ALWAYS_BRACES_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/block_delimiters.rb:177 +RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(nil), String) + +# Corrector to correct conditional assignment in `case` statements. +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:609 +class RuboCop::Cop::Style::CaseCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:614 + def correct(corrector, cop, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:624 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:644 + def extract_branches(case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:638 + def extract_tail_branches(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:654 + def move_branch_inside_condition(corrector, branch, condition, assignment, column); end + end +end + +# Checks for uses of the case equality operator(===). +# +# If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of +# the case equality operator is a constant. +# +# @example +# # bad +# (1..100) === 7 +# /something/ === some_string +# +# # good +# something.is_a?(Array) +# (1..100).include?(7) +# /something/.match?(some_string) +# @example AllowOnConstant: false (default) +# # bad +# Array === something +# @example AllowOnConstant: true +# # good +# Array === something +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:29 +class RuboCop::Cop::Style::CaseEquality < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:36 + def case_equality?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:38 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:51 + def const?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:59 + def replacement(lhs, rhs); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:32 +RuboCop::Cop::Style::CaseEquality::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/case_equality.rb:33 +RuboCop::Cop::Style::CaseEquality::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `if-elsif` constructions +# can be replaced with `case-when`. +# +# @example +# # bad +# if status == :active +# perform_action +# elsif status == :inactive || status == :hibernating +# check_timeout +# else +# final_action +# end +# +# # good +# case status +# when :active +# perform_action +# when :inactive, :hibernating +# check_timeout +# else +# final_action +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:34 +class RuboCop::Cop::Style::CaseLikeIf < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:40 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:64 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:214 + def branch_conditions(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:232 + def class_reference?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:149 + def collect_conditions(node, target, conditions); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:203 + def condition_from_binary_op(lhs, rhs, target); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:185 + def condition_from_equality_node(node, target); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:196 + def condition_from_include_or_cover_node(node, target); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:191 + def condition_from_match_node(node, target); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:168 + def condition_from_send_node(node, target); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:223 + def const_reference?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:241 + def correction_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:236 + def deparenthesize(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:85 + def find_target(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:119 + def find_target_in_equality_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:131 + def find_target_in_include_or_cover_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:137 + def find_target_in_match_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:104 + def find_target_in_send_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:257 + def regexp_with_named_captures?(node); end + + # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides) + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:246 + def regexp_with_working_captures?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:79 + def should_check?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/case_like_if.rb:38 +RuboCop::Cop::Style::CaseLikeIf::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the character literal ?x. +# Starting with Ruby 1.9 character literals are +# essentially one-character strings, so this syntax +# is mostly redundant at this point. +# +# ? character literal can be used to express meta and control character. +# That's a good use case of ? literal so it doesn't count it as an offense. +# +# @example +# # bad +# ?x +# +# # good +# 'x' +# +# # good - control & meta escapes +# ?\C-\M-d +# "\C-\M-d" # same as above +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:24 +class RuboCop::Cop::Style::CharacterLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:35 + def autocorrect(corrector, node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:53 + def correct_style_detected; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:30 + def offense?(node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:49 + def opposite_style_detected; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/character_literal.rb:28 +RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String) + +# Checks the style of children definitions at classes and +# modules. Basically there are two different styles: +# +# The compact style is only forced for classes/modules with one child. +# +# @example EnforcedStyle: nested (default) +# # good +# # have each child on its own line +# class Foo +# class Bar +# end +# end +# @example EnforcedStyle: compact +# # good +# # combine definitions as much as possible +# class Foo::Bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:33 +class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:41 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:47 + def on_module(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:88 + def add_trailing_end(corrector, node, padding); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:177 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:166 + def check_compact_style(node, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:158 + def check_nested_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:148 + def check_style(node, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:93 + def compact_definition(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:114 + def compact_identifier_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:99 + def compact_node(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:187 + def compact_node_name?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:104 + def compact_replacement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:127 + def configured_indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:144 + def indent_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:140 + def leading_spaces(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:183 + def needs_compacting?(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:61 + def nest_definition(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:53 + def nest_or_compact(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:119 + def remove_end(corrector, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:70 + def replace_namespace_keyword(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:79 + def split_on_double_colon(corrector, node, padding); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:131 + def unindent(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:39 +RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_and_module_children.rb:38 +RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String) + +# Enforces consistent use of `Object#is_a?` or `Object#kind_of?`. +# +# @example EnforcedStyle: is_a? (default) +# # bad +# var.kind_of?(Date) +# var.kind_of?(Integer) +# +# # good +# var.is_a?(Date) +# var.is_a?(Integer) +# @example EnforcedStyle: kind_of? +# # bad +# var.is_a?(Time) +# var.is_a?(String) +# +# # good +# var.kind_of?(Time) +# var.kind_of?(String) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_check.rb:26 +class RuboCop::Cop::Style::ClassCheck < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_check.rb:44 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_check.rb:33 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_check.rb:30 +RuboCop::Cop::Style::ClassCheck::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_check.rb:31 +RuboCop::Cop::Style::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of `Object#instance_of?` instead of class comparison +# for equality. +# `==`, `equal?`, and `eql?` methods are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# var.class == Date +# var.class.equal?(Date) +# var.class.eql?(Date) +# var.class.name == 'Date' +# +# # good +# var.instance_of?(Date) +# @example AllowedMethods: [] (default) +# # good +# var.instance_of?(Date) +# +# # bad +# var.class == Date +# var.class.equal?(Date) +# var.class.eql?(Date) +# var.class.name == 'Date' +# @example AllowedMethods: [`==`] +# # good +# var.instance_of?(Date) +# var.class == Date +# var.class.name == 'Date' +# +# # bad +# var.class.equal?(Date) +# var.class.eql?(Date) +# @example AllowedPatterns: [] (default) +# # good +# var.instance_of?(Date) +# +# # bad +# var.class == Date +# var.class.equal?(Date) +# var.class.eql?(Date) +# var.class.name == 'Date' +# @example AllowedPatterns: [`/eq/`] +# # good +# var.instance_of?(Date) +# var.class.equal?(Date) +# var.class.eql?(Date) +# +# # bad +# var.class == Date +# var.class.name == 'Date' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:61 +class RuboCop::Cop::Style::ClassEqualityComparison < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:72 + def class_comparison_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:78 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:96 + def class_name(class_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:108 + def offense_range(receiver_node, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:67 +RuboCop::Cop::Style::ClassEqualityComparison::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_equality_comparison.rb:69 +RuboCop::Cop::Style::ClassEqualityComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of the class/module name instead of +# self, when defining class/module methods. +# +# @example +# # bad +# class SomeClass +# def SomeClass.class_method +# # ... +# end +# end +# +# # good +# class SomeClass +# def self.class_method +# # ... +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods.rb:23 +class RuboCop::Cop::Style::ClassMethods < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods.rb:28 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods.rb:28 + def on_module(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods.rb:41 + def check_defs(name, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods.rb:26 +RuboCop::Cop::Style::ClassMethods::MSG = T.let(T.unsafe(nil), String) + +# Enforces using `def self.method_name` or `class << self` to define class methods. +# +# @example EnforcedStyle: def_self (default) +# # bad +# class SomeClass +# class << self +# attr_accessor :class_accessor +# +# def class_method +# # ... +# end +# end +# end +# +# # good +# class SomeClass +# def self.class_method +# # ... +# end +# +# class << self +# attr_accessor :class_accessor +# end +# end +# +# # good - contains private method +# class SomeClass +# class << self +# attr_accessor :class_accessor +# +# private +# +# def private_class_method +# # ... +# end +# end +# end +# @example EnforcedStyle: self_class +# # bad +# class SomeClass +# def self.class_method +# # ... +# end +# end +# +# # good +# class SomeClass +# class << self +# def class_method +# # ... +# end +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:61 +class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:81 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:71 + def on_sclass(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:95 + def all_methods_public?(sclass_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:115 + def autocorrect_sclass(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:102 + def def_nodes(sclass_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:91 + def def_self_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:141 + def extract_def_from_sclass(def_node, sclass_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:152 + def indentation_diff(node1, node2); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:137 + def sclass_only_has_methods?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:68 +RuboCop::Cop::Style::ClassMethodsDefinitions::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_methods_definitions.rb:69 +RuboCop::Cop::Style::ClassMethodsDefinitions::MSG_SCLASS = T.let(T.unsafe(nil), String) + +# Checks for uses of class variables. Offenses +# are signaled only on assignment to class variables to +# reduce the number of offenses that would be reported. +# +# You have to be careful when setting a value for a class +# variable; if a class has been inherited, changing the +# value of a class variable also affects the inheriting +# classes. This means that it's almost always better to +# use a class instance variable instead. +# +# @example +# # bad +# class A +# @@test = 10 +# end +# +# class A +# def self.test(name, value) +# class_variable_set("@@#{name}", value) +# end +# end +# +# class A; end +# A.class_variable_set(:@@test, 10) +# +# # good +# class A +# @test = 10 +# end +# +# class A +# def test +# @@test # you can access class variable without offense +# end +# end +# +# class A +# def self.test(name) +# class_variable_get("@@#{name}") # you can access without offense +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_vars.rb:48 +class RuboCop::Cop::Style::ClassVars < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_vars.rb:52 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/class_vars.rb:56 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_vars.rb:49 +RuboCop::Cop::Style::ClassVars::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/class_vars.rb:50 +RuboCop::Cop::Style::ClassVars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where custom logic on rejection nils from arrays +# and hashes can be replaced with `{Array,Hash}#{compact,compact!}`. +# +# @example +# # bad +# array.reject(&:nil?) +# array.reject { |e| e.nil? } +# array.select { |e| !e.nil? } +# +# # good +# array.compact +# +# # bad +# hash.reject!(&:nil?) +# hash.reject! { |k, v| v.nil? } +# hash.select! { |k, v| !v.nil? } +# +# # good +# hash.compact! +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:34 +class RuboCop::Cop::Style::CollectionCompact < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:70 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:50 + def reject_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:43 + def reject_method_with_block_pass?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:60 + def select_method?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:97 + def good_method_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:81 + def offense_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:105 + def range(begin_pos_node, end_pos_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:38 +RuboCop::Cop::Style::CollectionCompact::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/collection_compact.rb:40 +RuboCop::Cop::Style::CollectionCompact::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of consistent method names +# from the Enumerable module. +# +# You can customize the mapping from undesired method to desired method. +# +# e.g. to use `detect` over `find`: +# +# Style/CollectionMethods: +# PreferredMethods: +# find: detect +# +# @example +# # These examples are based on the default mapping for `PreferredMethods`. +# +# # bad +# items.collect +# items.collect! +# items.inject +# items.detect +# items.find_all +# items.member? +# +# # good +# items.map +# items.map! +# items.reduce +# items.find +# items.select +# items.include? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:41 +class RuboCop::Cop::Style::CollectionMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:47 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:47 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:53 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:61 + def check_method_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:70 + def implicit_block?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:78 + def message(node); end + + # Some enumerable methods accept a bare symbol (ie. _not_ Symbol#to_proc) instead + # of a block. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:84 + def methods_accepting_symbol; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/collection_methods.rb:45 +RuboCop::Cop::Style::CollectionMethods::MSG = T.let(T.unsafe(nil), String) + +# Checks for methods invoked via the :: operator instead +# of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir). +# +# @example +# # bad +# Timeout::timeout(500) { do_something } +# FileUtils::rmdir(dir) +# Marshal::dump(obj) +# +# # good +# Timeout.timeout(500) { do_something } +# FileUtils.rmdir(dir) +# Marshal.dump(obj) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_call.rb:20 +class RuboCop::Cop::Style::ColonMethodCall < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_call.rb:26 + def java_type_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_call.rb:35 + def on_send(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_call.rb:31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_call.rb:23 +RuboCop::Cop::Style::ColonMethodCall::MSG = T.let(T.unsafe(nil), String) + +# Checks for class methods that are defined using the `::` +# operator instead of the `.` operator. +# +# @example +# # bad +# class Foo +# def self::bar +# end +# end +# +# # good +# class Foo +# def self.bar +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_definition.rb:22 +class RuboCop::Cop::Style::ColonMethodDefinition < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_definition.rb:27 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/colon_method_definition.rb:25 +RuboCop::Cop::Style::ColonMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where multiple consecutive loops over the same data +# can be combined into a single loop. It is very likely that combining them +# will make the code more efficient and more concise. +# +# @example +# # bad +# def method +# items.each do |item| +# do_something(item) +# end +# +# items.each do |item| +# do_something_else(item) +# end +# end +# +# # good +# def method +# items.each do |item| +# do_something(item) +# do_something_else(item) +# end +# end +# +# # bad +# def method +# for item in items do +# do_something(item) +# end +# +# for item in items do +# do_something_else(item) +# end +# end +# +# # good +# def method +# for item in items do +# do_something(item) +# do_something_else(item) +# end +# end +# +# # good +# def method +# each_slice(2) { |slice| do_something(slice) } +# each_slice(3) { |slice| do_something(slice) } +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:59 +class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:62 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:71 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:62 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:80 + def collection_looping_method?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:86 + def same_collection_looping?(node, sibling); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/combinable_loops.rb:60 +RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String) + +# Enforces using `` or %x around command literals. +# +# @example EnforcedStyle: backticks (default) +# # bad +# folders = %x(find . -type d).split +# +# # bad +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# +# # good +# folders = `find . -type d`.split +# +# # good +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# @example EnforcedStyle: mixed +# # bad +# folders = %x(find . -type d).split +# +# # bad +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# +# # good +# folders = `find . -type d`.split +# +# # good +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# @example EnforcedStyle: percent_x +# # bad +# folders = `find . -type d`.split +# +# # bad +# ` +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ` +# +# # good +# folders = %x(find . -type d).split +# +# # good +# %x( +# ln -s foo.example.yml foo.example +# ln -s bar.example.yml bar.example +# ) +# @example AllowInnerBackticks: false (default) +# # If `false`, the cop will always recommend using `%x` if one or more +# # backticks are found in the command string. +# +# # bad +# `echo \`ls\`` +# +# # good +# %x(echo `ls`) +# @example AllowInnerBackticks: true +# # good +# `echo \`ls\`` +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:78 +class RuboCop::Cop::Style::CommandLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:85 + def on_xstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:146 + def allow_inner_backticks?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:122 + def allowed_backtick_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:131 + def allowed_percent_x_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:109 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:159 + def backtick_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:97 + def check_backtick_literal(node, message); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:103 + def check_percent_x_literal(node, message); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:167 + def command_delimiter; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:150 + def contains_backtick?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:142 + def contains_disallowed_backtick?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:171 + def default_delimiter; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:154 + def node_body(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:163 + def preferred_delimiter; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:175 + def preferred_delimiters_config; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:82 +RuboCop::Cop::Style::CommandLiteral::MSG_USE_BACKTICKS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/command_literal.rb:83 +RuboCop::Cop::Style::CommandLiteral::MSG_USE_PERCENT_X = T.let(T.unsafe(nil), String) + +# Checks that comment annotation keywords are written according +# to guidelines. +# +# Annotation keywords can be specified by overriding the cop's `Keywords` +# configuration. Keywords are allowed to be single words or phrases. +# +# NOTE: With a multiline comment block (where each line is only a +# comment), only the first line will be able to register an offense, even +# if an annotation keyword starts another line. This is done to prevent +# incorrect registering of keywords (eg. `review`) inside a paragraph as an +# annotation. +# +# @example RequireColon: true (default) +# # bad +# # TODO make better +# +# # good +# # TODO: make better +# +# # bad +# # TODO:make better +# +# # good +# # TODO: make better +# +# # bad +# # fixme: does not work +# +# # good +# # FIXME: does not work +# +# # bad +# # Optimize does not work +# +# # good +# # OPTIMIZE: does not work +# @example RequireColon: false +# # bad +# # TODO: make better +# +# # good +# # TODO make better +# +# # bad +# # fixme does not work +# +# # good +# # FIXME does not work +# +# # bad +# # Optimize does not work +# +# # good +# # OPTIMIZE does not work +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:61 +class RuboCop::Cop::Style::CommentAnnotation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:73 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:110 + def annotation_range(annotation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:114 + def correct_offense(corrector, range, keyword); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:102 + def first_comment_line?(comments, index); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:106 + def inline_comment?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:124 + def keywords; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:87 + def register_offense(annotation); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:120 + def requires_colon?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:71 +RuboCop::Cop::Style::CommentAnnotation::MISSING_NOTE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:65 +RuboCop::Cop::Style::CommentAnnotation::MSG_COLON_STYLE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/comment_annotation.rb:68 +RuboCop::Cop::Style::CommentAnnotation::MSG_SPACE_STYLE = T.let(T.unsafe(nil), String) + +# Checks for comments put on the same line as some keywords. +# These keywords are: `class`, `module`, `def`, `begin`, `end`. +# +# Note that some comments +# are allowed. +# +# Autocorrection removes comments from `end` keyword and keeps comments +# for `class`, `module`, `def` and `begin` above the keyword. +# +# @example +# # bad +# if condition +# statement +# end # end if +# +# # bad +# class X # comment +# statement +# end +# +# # bad +# def x; end # comment +# +# # good +# if condition +# statement +# end +# +# # good +# class X # :nodoc: +# y +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:43 +class RuboCop::Cop::Style::CommentedKeyword < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:57 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:80 + def offensive?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:67 + def register_offense(comment, matched_keyword); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:86 + def source_line(comment); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:52 +RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENTS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:53 +RuboCop::Cop::Style::CommentedKeyword::ALLOWED_COMMENT_REGEXES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:49 +RuboCop::Cop::Style::CommentedKeyword::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:50 +RuboCop::Cop::Style::CommentedKeyword::KEYWORD_REGEXES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:47 +RuboCop::Cop::Style::CommentedKeyword::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/commented_keyword.rb:55 +RuboCop::Cop::Style::CommentedKeyword::REGEXP = T.let(T.unsafe(nil), Regexp) + +# Check for `if` and `case` statements where each branch is used for +# assignment to the same variable when using the return of the +# condition can be used instead. +# +# @example EnforcedStyle: assign_to_condition (default) +# # bad +# if foo +# bar = 1 +# else +# bar = 2 +# end +# +# case foo +# when 'a' +# bar += 1 +# else +# bar += 2 +# end +# +# if foo +# some_method +# bar = 1 +# else +# some_other_method +# bar = 2 +# end +# +# # good +# bar = if foo +# 1 +# else +# 2 +# end +# +# bar += case foo +# when 'a' +# 1 +# else +# 2 +# end +# +# bar << if foo +# some_method +# 1 +# else +# some_other_method +# 2 +# end +# @example EnforcedStyle: assign_inside_condition +# # bad +# bar = if foo +# 1 +# else +# 2 +# end +# +# bar += case foo +# when 'a' +# 1 +# else +# 2 +# end +# +# bar << if foo +# some_method +# 1 +# else +# some_other_method +# 2 +# end +# +# # good +# if foo +# bar = 1 +# else +# bar = 2 +# end +# +# case foo +# when 'a' +# bar += 1 +# else +# bar += 2 +# end +# +# if foo +# some_method +# bar = 1 +# else +# some_other_method +# bar = 2 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:210 +class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Style::ConditionalAssignmentHelper + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # The shovel operator `<<` does not have its own type. It is a `send` + # type. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:230 + def assignment_type?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:311 + def candidate_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:266 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:276 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:252 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_op_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:238 + def on_or_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:246 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:317 + def allowed_single_line?(branches); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:388 + def allowed_statements?(branches); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:313 + def allowed_ternary?(assignment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:321 + def assignment_node(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:365 + def assignment_types_match?(*nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:380 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:306 + def candidate_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:288 + def check_assignment_to_condition(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:371 + def check_node(node, branches); end + + # If `Layout/LineLength` is enabled, we do not want to introduce an + # offense by autocorrecting this cop. Find the max configured line + # length. Find the longest line of condition. Remove the assignment + # from lines that contain the offending assignment because after + # correcting, this will not be on the line anymore. Check if the length + # of the longest line + the length of the corrected assignment is + # greater than the max configured line length + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:404 + def correction_exceeds_line_limit?(node, branches); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:439 + def include_ternary?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:431 + def indentation_width; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:358 + def lhs_all_match?(branches); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:423 + def line_length_cop_enabled?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:416 + def longest_line(node, assignment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:412 + def longest_line_exceeds_line_limit?(node, assignment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:427 + def max_line_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:342 + def move_assignment_inside_condition(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:332 + def move_assignment_outside_condition(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:435 + def single_line_conditions_only?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:354 + def ternary_condition?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:219 +RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:217 +RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:222 +RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:221 +RuboCop::Cop::Style::ConditionalAssignment::INDENTATION_WIDTH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:220 +RuboCop::Cop::Style::ConditionalAssignment::LINE_LENGTH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:223 +RuboCop::Cop::Style::ConditionalAssignment::MAX = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:216 +RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:224 +RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:218 +RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:225 +RuboCop::Cop::Style::ConditionalAssignment::WIDTH = T.let(T.unsafe(nil), String) + +# Helper module to provide common methods to classes needed for the +# ConditionalAssignment Cop. +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:8 +module RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::AST::NodePattern::Macros + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:64 + def end_with_eq?(sym); end + + # `elsif` branches show up in the `node` as an `else`. We need + # to recursively iterate over all `else` branches and consider all + # but the last `node` an `elsif` branch and consider the last `node` + # the actual `else` branch. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:20 + def expand_elses(branch); end + + # `when` nodes contain the entire branch including the condition. + # We only need the contents of the branch, not the condition. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:28 + def expand_when_branches(when_branches); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:55 + def indent(cop, source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:37 + def lhs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:32 + def tail(branch); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:109 + def assignment_rhs_exist?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:70 + def expand_elsif(node, elsif_branches = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:96 + def lhs_for_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:83 + def lhs_for_send(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:105 + def setter_method?(method_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:13 +RuboCop::Cop::Style::ConditionalAssignmentHelper::ALIGN_WITH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:12 +RuboCop::Cop::Style::ConditionalAssignmentHelper::END_ALIGNMENT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:11 +RuboCop::Cop::Style::ConditionalAssignmentHelper::EQUAL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:14 +RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), String) + +# Helper module to provide common methods to ConditionalAssignment +# correctors +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:446 +module RuboCop::Cop::Style::ConditionalCorrectorHelper + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:465 + def assignment(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:495 + def correct_branches(corrector, branches); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:472 + def correct_if_branches(corrector, cop, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:447 + def remove_whitespace_in_branches(corrector, branch, condition, column); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:482 + def replace_branch_assignment(corrector, branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:458 + def white_space_range(node, column); end +end + +# Checks that constants defined in classes and modules have +# an explicit visibility declaration. By default, Ruby makes all class- +# and module constants public, which litters the public API of the +# class or module. Explicitly declaring a visibility makes intent more +# clear, and prevents outside actors from touching private state. +# +# @example +# +# # bad +# class Foo +# BAR = 42 +# BAZ = 43 +# end +# +# # good +# class Foo +# BAR = 42 +# private_constant :BAR +# +# BAZ = 43 +# public_constant :BAZ +# end +# @example IgnoreModules: false (default) +# # bad +# class Foo +# MyClass = Struct.new() +# end +# +# # good +# class Foo +# MyClass = Struct.new() +# public_constant :MyClass +# end +# @example IgnoreModules: true +# # good +# class Foo +# MyClass = Struct.new() +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:47 +class RuboCop::Cop::Style::ConstantVisibility < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:51 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:96 + def visibility_declaration_for?(param0 = T.unsafe(nil), param1); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:76 + def class_or_module_scope?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:62 + def ignore_modules?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:100 + def match_name?(name, constant_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:70 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:66 + def module?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:87 + def visibility_declaration?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/constant_visibility.rb:48 +RuboCop::Cop::Style::ConstantVisibility::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:18 +class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:25 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:44 + def autocorrect_notice; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:75 + def encoding_token?(processed_source, token_index); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:61 + def insert_notice_before(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:40 + def notice; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:82 + def notice_found?(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:48 + def offense_range; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:68 + def shebang_token?(processed_source, token_index); end + + # @raise [Warning] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:52 + def verify_autocorrect_notice!; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:23 +RuboCop::Cop::Style::Copyright::AUTOCORRECT_EMPTY_WARNING = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/copyright.rb:22 +RuboCop::Cop::Style::Copyright::MSG = T.let(T.unsafe(nil), String) + +# Checks for consistent usage of the `DateTime` class over the +# `Time` class. This cop is disabled by default since these classes, +# although highly overlapping, have particularities that make them not +# replaceable in certain situations when dealing with multiple timezones +# and/or DST. +# +# @example +# +# # bad - uses `DateTime` for current time +# DateTime.now +# +# # good - uses `Time` for current time +# Time.now +# +# # bad - uses `DateTime` for modern date +# DateTime.iso8601('2016-06-29') +# +# # good - uses `Time` for modern date +# Time.iso8601('2016-06-29') +# +# # good - uses `DateTime` with start argument for historical date +# DateTime.iso8601('1751-04-23', Date::ENGLAND) +# @example AllowCoercion: false (default) +# +# # bad - coerces to `DateTime` +# something.to_datetime +# +# # good - coerces to `Time` +# something.to_time +# @example AllowCoercion: true +# +# # good +# something.to_datetime +# +# # good +# something.to_time +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:49 +class RuboCop::Cop::Style::DateTime < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:56 + def date_time?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:61 + def historic_date?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:70 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:66 + def to_datetime?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:85 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:81 + def disallow_coercion?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:52 +RuboCop::Cop::Style::DateTime::CLASS_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/date_time.rb:53 +RuboCop::Cop::Style::DateTime::COERCION_MSG = T.let(T.unsafe(nil), String) + +# Checks for parentheses in the definition of a method, +# that does not take any arguments. Both instance and +# class/singleton methods are checked. +# +# @example +# +# # bad +# def foo() +# do_something +# end +# +# # good +# def foo +# do_something +# end +# +# # bad +# def foo() = do_something +# +# # good +# def foo = do_something +# +# # good (without parentheses it's a syntax error) +# def foo() do_something end +# @example +# +# # bad +# def Baz.foo() +# do_something +# end +# +# # good +# def Baz.foo +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/def_with_parentheses.rb:42 +class RuboCop::Cop::Style::DefWithParentheses < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/def_with_parentheses.rb:47 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/def_with_parentheses.rb:47 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/def_with_parentheses.rb:45 +RuboCop::Cop::Style::DefWithParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where the `#__dir__` method can replace more +# complex constructs to retrieve a canonicalized absolute path to the +# current file. +# +# @example +# # bad +# path = File.expand_path(File.dirname(__FILE__)) +# +# # bad +# path = File.dirname(File.realpath(__FILE__)) +# +# # good +# path = __dir__ +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:19 +class RuboCop::Cop::Style::Dir < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:29 + def dir_replacement?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:34 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:44 + def file_keyword?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:25 +RuboCop::Cop::Style::Dir::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/dir.rb:26 +RuboCop::Cop::Style::Dir::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Detects comments to enable/disable RuboCop. +# This is useful if want to make sure that every RuboCop error gets fixed +# and not quickly disabled with a comment. +# +# Specific cops can be allowed with the `AllowedCops` configuration. Note that +# +# @example +# # bad +# # rubocop:disable Metrics/AbcSize +# def foo +# end +# # rubocop:enable Metrics/AbcSize +# +# # good +# def foo +# end +# @example AllowedCops: [Metrics/AbcSize] +# # good +# # rubocop:disable Metrics/AbcSize +# def foo +# end +# # rubocop:enable Metrics/AbcSize +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:33 +class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:40 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:77 + def allowed_cops; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:81 + def any_cops_allowed?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:72 + def directive_cops(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:53 + def register_offense(comment, directive_cops, disallowed_cops); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:37 +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:38 +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String) + +# When using `class_eval` (or other `eval`) with string interpolation, +# add a comment block showing its appearance if interpolated (a practice used in Rails code). +# +# @example +# # from activesupport/lib/active_support/core_ext/string/output_safety.rb +# +# # bad +# UNSAFE_STRING_METHODS.each do |unsafe_method| +# if 'String'.respond_to?(unsafe_method) +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}(*params, &block) +# to_str.#{unsafe_method}(*params, &block) +# end +# +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# end +# end +# +# # good, inline comments in heredoc +# UNSAFE_STRING_METHODS.each do |unsafe_method| +# if 'String'.respond_to?(unsafe_method) +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}(*params, &block) # def capitalize(*params, &block) +# to_str.#{unsafe_method}(*params, &block) # to_str.capitalize(*params, &block) +# end # end +# +# def #{unsafe_method}!(*params) # def capitalize!(*params) +# @dirty = true # @dirty = true +# super # super +# end # end +# EOT +# end +# end +# +# # good, block comments in heredoc +# class_eval <<-EOT, __FILE__, __LINE__ + 1 +# # def capitalize!(*params) +# # @dirty = true +# # super +# # end +# +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# +# # good, block comments before heredoc +# class_eval( +# # def capitalize!(*params) +# # @dirty = true +# # super +# # end +# +# <<-EOT, __FILE__, __LINE__ + 1 +# def #{unsafe_method}!(*params) +# @dirty = true +# super +# end +# EOT +# ) +# +# # bad - interpolated string without comment +# class_eval("def #{unsafe_method}!(*params); end") +# +# # good - with inline comment or replace it with block comment using heredoc +# class_eval("def #{unsafe_method}!(*params); end # def capitalize!(*params); end") +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:77 +class RuboCop::Cop::Style::DocumentDynamicEvalDefinition < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:84 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:107 + def comment_block_docs?(arg_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:147 + def comment_regexp(arg_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:126 + def heredoc_comment_blocks(heredoc_body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:100 + def inline_comment_docs?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:96 + def interpolated?(arg_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:136 + def merge_adjacent_comments(line, index, hash); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:117 + def preceding_comment_blocks(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:156 + def source_to_regexp(source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:78 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::BLOCK_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:79 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:80 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/document_dynamic_eval_definition.rb:82 +RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for missing top-level documentation of classes and +# modules. Classes with no body are exempt from the check and so are +# namespace modules - modules that have nothing in their bodies except +# classes, other modules, constant definitions or constant visibility +# declarations. +# +# The documentation requirement is annulled if the class or module has +# same for all its children. +# +# @example +# # bad +# class Person +# # ... +# end +# +# module Math +# end +# +# # good +# # Description/Explanation of Person class +# class Person +# # ... +# end +# +# # allowed +# # Class without body +# class Person +# end +# +# # Namespace - A namespace can be a class or a module +# # Containing a class +# module Namespace +# # Description/Explanation of Person class +# class Person +# # ... +# end +# end +# +# # Containing constant visibility declaration +# module Namespace +# class Private +# end +# +# private_constant :Private +# end +# +# # Containing constant definition +# module Namespace +# Public = Class.new +# end +# +# # Macro calls +# module Namespace +# extend Foo +# end +# @example AllowedConstants: ['ClassMethods'] +# +# # good +# module A +# module ClassMethods +# # ... +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:72 +class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:79 + def constant_definition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:85 + def constant_visibility_declaration?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:89 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:95 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:82 + def outer_module(param0); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:168 + def allowed_constants; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:101 + def check(node, body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:141 + def compact_namespace?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:137 + def constant_allowed?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:133 + def constant_declaration?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:172 + def identifier(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:118 + def macro_only?(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:123 + def namespace?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:164 + def nodoc(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:160 + def nodoc?(comment, require_all: T.unsafe(nil)); end + + # Note: How end-of-line comments are associated with code changed in + # parser-2.2.0.4. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:150 + def nodoc_comment?(node, require_all: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:113 + def nodoc_self_or_outer_module?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:178 + def qualify_const(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/documentation.rb:76 +RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String) + +# Checks for missing documentation comment for public methods. +# It can optionally be configured to also require documentation for +# non-public methods. +# +# @example +# +# # bad +# +# class Foo +# def bar +# puts baz +# end +# end +# +# module Foo +# def bar +# puts baz +# end +# end +# +# def foo.bar +# puts baz +# end +# +# # good +# +# class Foo +# # Documentation +# def bar +# puts baz +# end +# end +# +# module Foo +# # Documentation +# def bar +# puts baz +# end +# end +# +# # Documentation +# def foo.bar +# puts baz +# end +# @example RequireForNonPublicMethods: false (default) +# # good +# class Foo +# protected +# def do_something +# end +# end +# +# class Foo +# private +# def do_something +# end +# end +# @example RequireForNonPublicMethods: true +# # bad +# class Foo +# protected +# def do_something +# end +# end +# +# class Foo +# private +# def do_something +# end +# end +# +# # good +# class Foo +# protected +# # Documentation +# def do_something +# end +# end +# +# class Foo +# private +# # Documentation +# def do_something +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:94 +class RuboCop::Cop::Style::DocumentationMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::VisibilityHelp + include ::RuboCop::Cop::DefNode + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:101 + def module_function_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:105 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:105 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:113 + def check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:120 + def require_for_non_public_methods?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/documentation_method.rb:98 +RuboCop::Cop::Style::DocumentationMethod::MSG = T.let(T.unsafe(nil), String) + +# Detects double disable comments on one line. This is mostly to catch +# automatically generated comments that need to be regenerated. +# +# @example +# # bad +# def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize +# end +# +# # good +# # rubocop:disable Metrics/AbcSize +# def f # rubocop:disable Style/For +# end +# # rubocop:enable Metrics/AbcSize +# +# # if both fit on one line +# def f # rubocop:disable Style/For, Metrics/AbcSize +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/double_cop_disable_directive.rb:27 +class RuboCop::Cop::Style::DoubleCopDisableDirective < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_cop_disable_directive.rb:34 + def on_new_investigation; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/double_cop_disable_directive.rb:32 +RuboCop::Cop::Style::DoubleCopDisableDirective::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of double negation (`!!`) to convert something to a boolean value. +# +# When using `EnforcedStyle: allowed_in_returns`, allow double negation in contexts +# that use boolean as a return value. When using `EnforcedStyle: forbidden`, double negation +# should be forbidden always. +# +# NOTE: when `something` is a boolean value +# `!!something` and `!something.nil?` are not the same thing. +# As you're unlikely to write code that can accept values of any type +# this is rarely a problem in practice. +# +# @example +# # bad +# !!something +# +# # good +# !something.nil? +# @example EnforcedStyle: allowed_in_returns (default) +# # good +# def foo? +# !!return_value +# end +# +# define_method :foo? do +# !!return_value +# end +# +# define_singleton_method :foo? do +# !!return_value +# end +# @example EnforcedStyle: forbidden +# # bad +# def foo? +# !!return_value +# end +# +# define_method :foo? do +# !!return_value +# end +# +# define_singleton_method :foo? do +# !!return_value +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:61 +class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:69 + def double_negative?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:84 + def allowed_in_returns?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:111 + def define_mehod?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:138 + def double_negative_condition_return_value?(node, last_child, conditional_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:88 + def end_of_method_definition?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:120 + def find_conditional_node_from_ascendant(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:103 + def find_def_node_from_ascendant(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:127 + def find_last_child(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:147 + def find_parent_not_enumerable(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:65 +RuboCop::Cop::Style::DoubleNegation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/double_negation.rb:66 +RuboCop::Cop::Style::DoubleNegation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for loops which iterate a constant number of times, +# using a Range literal and `#each`. This can be done more readably using +# `Integer#times`. +# +# This check only applies if the block takes no parameters. +# +# @example +# # bad +# (1..5).each { } +# +# # good +# 5.times { } +# @example +# # bad +# (0...10).each {} +# +# # good +# 10.times {} +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/each_for_simple_loop.rb:25 +class RuboCop::Cop::Style::EachForSimpleLoop < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_for_simple_loop.rb:49 + def offending_each_range(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_for_simple_loop.rb:30 + def on_block(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/each_for_simple_loop.rb:28 +RuboCop::Cop::Style::EachForSimpleLoop::MSG = T.let(T.unsafe(nil), String) + +# Looks for inject / reduce calls where the passed in object is +# returned at the end and so could be replaced by each_with_object without +# the need to return the object at the end. +# +# However, we can't replace with each_with_object if the accumulator +# parameter is assigned to within the block. +# +# @example +# # bad +# [1, 2].inject({}) { |a, e| a[e] = e; a } +# +# # good +# [1, 2].each_with_object({}) { |e, a| a[e] = e } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:19 +class RuboCop::Cop::Style::EachWithObject < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:60 + def each_with_object_block_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:65 + def each_with_object_numblock_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:26 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:43 + def on_numblock(node); end + + private + + # if the accumulator parameter is assigned to in the block, + # then we can't convert to each_with_object + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:102 + def accumulator_param_assigned_to?(body, args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:69 + def autocorrect_block(corrector, node, return_value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:84 + def autocorrect_numblock(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:121 + def first_argument_returned?(args, return_value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:114 + def return_value(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:129 + def return_value_occupies_whole_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:96 + def simple_method_arg?(method_arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:133 + def whole_line_expression(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:24 +RuboCop::Cop::Style::EachWithObject::METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/each_with_object.rb:23 +RuboCop::Cop::Style::EachWithObject::MSG = T.let(T.unsafe(nil), String) + +# Checks for pipes for empty block parameters. Pipes for empty +# block parameters do not cause syntax errors, but they are redundant. +# +# @example +# # bad +# a do || +# do_something +# end +# +# # bad +# a { || do_something } +# +# # good +# a do +# end +# +# # good +# a { do_something } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_block_parameter.rb:24 +class RuboCop::Cop::Style::EmptyBlockParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_block_parameter.rb:31 + def on_block(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_block_parameter.rb:38 + def autocorrect(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_block_parameter.rb:29 +RuboCop::Cop::Style::EmptyBlockParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for case statements with an empty condition. +# +# @example +# +# # bad: +# case +# when x == 0 +# puts 'x is 0' +# when y == 0 +# puts 'y is 0' +# else +# puts 'neither is 0' +# end +# +# # good: +# if x == 0 +# puts 'x is 0' +# elsif y == 0 +# puts 'y is 0' +# else +# puts 'neither is 0' +# end +# +# # good: (the case condition node is not empty) +# case n +# when 0 +# puts 'zero' +# when 1 +# puts 'one' +# else +# puts 'more' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:38 +class RuboCop::Cop::Style::EmptyCaseCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:44 + def on_case(case_node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:58 + def autocorrect(corrector, case_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:65 + def correct_case_when(corrector, case_node, when_nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:77 + def correct_when_conditions(corrector, when_nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:92 + def keep_first_when_comment(case_range, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:102 + def replace_then_with_line_break(corrector, conditions, when_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_case_condition.rb:42 +RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String) + +# Checks for empty else-clauses, possibly including comments and/or an +# explicit `nil` depending on the EnforcedStyle. +# +# @example EnforcedStyle: both (default) +# # warn on empty else and else with nil in it +# +# # bad +# if condition +# statement +# else +# nil +# end +# +# # bad +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example EnforcedStyle: empty +# # warn only on empty else +# +# # bad +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# nil +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example EnforcedStyle: nil +# # warn on else with nil in it +# +# # bad +# if condition +# statement +# else +# nil +# end +# +# # good +# if condition +# statement +# else +# end +# +# # good +# if condition +# statement +# else +# statement +# end +# +# # good +# if condition +# statement +# end +# @example AllowComments: false (default) +# +# # bad +# if condition +# statement +# else +# # something comment +# nil +# end +# +# # bad +# if condition +# statement +# else +# # something comment +# end +# @example AllowComments: true +# +# # good +# if condition +# statement +# else +# # something comment +# nil +# end +# +# # good +# if condition +# statement +# else +# # something comment +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:127 +class RuboCop::Cop::Style::EmptyElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:139 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:135 + def on_normal_if_unless(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:172 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:193 + def autocorrect_forbidden?(type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:186 + def base_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:145 + def check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:180 + def comment_in_else?(loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:160 + def empty_check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:156 + def empty_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:197 + def missing_else_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:166 + def nil_check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:152 + def nil_style?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_else.rb:133 +RuboCop::Cop::Style::EmptyElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for using empty heredoc to reduce redundancy. +# +# @example +# +# # bad +# <<~EOS +# EOS +# +# <<-EOS +# EOS +# +# <<EOS +# EOS +# +# # good +# '' +# +# # bad +# do_something(<<~EOS) +# EOS +# +# do_something(<<-EOS) +# EOS +# +# do_something(<<EOS) +# EOS +# +# # good +# do_something('') +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:36 +class RuboCop::Cop::Style::EmptyHeredoc < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Heredoc + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:43 + def on_heredoc(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:63 + def enforce_double_quotes?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:59 + def preferred_string_literal; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:67 + def string_literals_config; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_heredoc.rb:41 +RuboCop::Cop::Style::EmptyHeredoc::MSG = T.let(T.unsafe(nil), String) + +# Checks for parentheses for empty lambda parameters. Parentheses +# for empty lambda parameters do not cause syntax errors, but they are +# redundant. +# +# @example +# # bad +# -> () { do_something } +# +# # good +# -> { do_something } +# +# # good +# -> (arg) { do_something(arg) } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_lambda_parameter.rb:19 +class RuboCop::Cop::Style::EmptyLambdaParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_lambda_parameter.rb:26 + def on_block(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_lambda_parameter.rb:35 + def autocorrect(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_lambda_parameter.rb:24 +RuboCop::Cop::Style::EmptyLambdaParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of a method, the result of which +# would be a literal, like an empty array, hash, or string. +# +# @example +# # bad +# a = Array.new +# h = Hash.new +# s = String.new +# +# # good +# a = [] +# h = {} +# s = '' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:19 +class RuboCop::Cop::Style::EmptyLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:31 + def array_node(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:40 + def array_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:34 + def hash_node(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:43 + def hash_with_block(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:50 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:37 + def str_node(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:111 + def correction(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:74 + def enforce_double_quotes?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:82 + def first_argument_unparenthesized?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:129 + def frozen_strings?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:102 + def offense_array_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:106 + def offense_hash_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:60 + def offense_message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:70 + def preferred_string_literal; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:89 + def replacement_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:78 + def string_literals_config; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:24 +RuboCop::Cop::Style::EmptyLiteral::ARR_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:25 +RuboCop::Cop::Style::EmptyLiteral::HASH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:28 +RuboCop::Cop::Style::EmptyLiteral::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_literal.rb:26 +RuboCop::Cop::Style::EmptyLiteral::STR_MSG = T.let(T.unsafe(nil), String) + +# Checks for the formatting of empty method definitions. +# By default it enforces empty method definitions to go on a single +# line (compact style), but it can be configured to enforce the `end` +# to go on its own line (expanded style). +# +# NOTE: A method definition is not considered empty if it contains +# comments. +# +# NOTE: Autocorrection will not be applied for the `compact` style +# if the resulting code is longer than the `Max` configuration for +# `Layout/LineLength`, but an offense will still be registered. +# +# @example EnforcedStyle: compact (default) +# # bad +# def foo(bar) +# end +# +# def self.foo(bar) +# end +# +# # good +# def foo(bar); end +# +# def foo(bar) +# # baz +# end +# +# def self.foo(bar); end +# @example EnforcedStyle: expanded +# # bad +# def foo(bar); end +# +# def self.foo(bar); end +# +# # good +# def foo(bar) +# end +# +# def self.foo(bar) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:47 +class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:54 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:54 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:95 + def compact?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:103 + def compact_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:73 + def correct_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:77 + def corrected(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:99 + def expanded?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:107 + def expanded_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:89 + def joint(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:111 + def max_line_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:69 + def message(_range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:51 +RuboCop::Cop::Style::EmptyMethod::MSG_COMPACT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/empty_method.rb:52 +RuboCop::Cop::Style::EmptyMethod::MSG_EXPANDED = T.let(T.unsafe(nil), String) + +# Checks ensures source files have no utf-8 encoding comments. +# +# @example +# # bad +# # encoding: UTF-8 +# # coding: UTF-8 +# # -*- coding: UTF-8 -*- +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:12 +class RuboCop::Cop::Style::Encoding < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:20 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:32 + def comments; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:43 + def offense?(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:47 + def register_offense(line_number, comment); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:17 +RuboCop::Cop::Style::Encoding::ENCODING_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:16 +RuboCop::Cop::Style::Encoding::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/encoding.rb:18 +RuboCop::Cop::Style::Encoding::SHEBANG = T.let(T.unsafe(nil), String) + +# Checks for END blocks. +# +# @example +# # bad +# END { puts 'Goodbye!' } +# +# # good +# at_exit { puts 'Goodbye!' } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/end_block.rb:15 +class RuboCop::Cop::Style::EndBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/end_block.rb:20 + def on_postexe(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/end_block.rb:18 +RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for endless methods. +# +# It can enforce either the use of endless methods definitions +# for single-lined method bodies, or disallow endless methods. +# +# Other method definition types are not considered by this cop. +# +# The supported styles are: +# +# * allow_single_line (default) - only single line endless method definitions are allowed. +# * allow_always - all endless method definitions are allowed. +# * disallow - all endless method definitions are disallowed. +# +# NOTE: Incorrect endless method definitions will always be +# corrected to a multi-line definition. +# +# @example EnforcedStyle: allow_single_line (default) +# # good +# def my_method() = x +# +# # bad, multi-line endless method +# def my_method() = x.foo +# .bar +# .baz +# @example EnforcedStyle: allow_always +# # good +# def my_method() = x +# +# # good +# def my_method() = x.foo +# .bar +# .baz +# @example EnforcedStyle: disallow +# # bad +# def my_method; x end +# +# # bad +# def my_method() = x.foo +# .bar +# .baz +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:49 +class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::TargetRubyVersion + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:60 + def on_def(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:95 + def arguments(node, missing = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:85 + def correct_to_multiline(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:70 + def handle_allow_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:79 + def handle_disallow_style(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:56 +RuboCop::Cop::Style::EndlessMethod::CORRECTION_STYLES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:57 +RuboCop::Cop::Style::EndlessMethod::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/endless_method.rb:58 +RuboCop::Cop::Style::EndlessMethod::MSG_MULTI_LINE = T.let(T.unsafe(nil), String) + +# Checks for consistent usage of `ENV['HOME']`. If `nil` is used as +# the second argument of `ENV.fetch`, it is treated as a bad case like `ENV[]`. +# +# @example +# +# # bad +# ENV['HOME'] +# ENV.fetch('HOME', nil) +# +# # good +# Dir.home +# +# # good +# ENV.fetch('HOME', default) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/env_home.rb:31 +class RuboCop::Cop::Style::EnvHome < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/env_home.rb:38 + def env_home?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/env_home.rb:45 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/env_home.rb:34 +RuboCop::Cop::Style::EnvHome::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/env_home.rb:35 +RuboCop::Cop::Style::EnvHome::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Ensures that eval methods (`eval`, `instance_eval`, `class_eval` +# and `module_eval`) are given filename and line number values (`__FILE__` +# and `__LINE__`). This data is used to ensure that any errors raised +# within the evaluated code will be given the correct identification +# in a backtrace. +# +# The cop also checks that the line number given relative to `__LINE__` is +# correct. +# +# This cop will autocorrect incorrect or missing filename and line number +# values. However, if `eval` is called without a binding argument, the cop +# will not attempt to automatically add a binding, or add filename and +# line values. +# +# This cop works only when a string literal is given as a code string. +# No offense is reported if a string variable is given as below: +# +# @example +# # bad +# eval <<-RUBY +# def do_something +# end +# RUBY +# +# # bad +# C.class_eval <<-RUBY +# def do_something +# end +# RUBY +# +# # good +# eval <<-RUBY, binding, __FILE__, __LINE__ + 1 +# def do_something +# end +# RUBY +# +# # good +# C.class_eval <<-RUBY, __FILE__, __LINE__ + 1 +# def do_something +# end +# RUBY +# @example +# # not checked +# code = <<-RUBY +# def do_something +# end +# RUBY +# eval code +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:56 +class RuboCop::Cop::Style::EvalWithLocation < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:74 + def line_with_offset?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:81 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:69 + def valid_eval_receiver?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:195 + def add_offense_for_different_line(node, line_node, line_diff); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:142 + def add_offense_for_incorrect_line(method_name, line_node, sign, line_diff); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:210 + def add_offense_for_missing_line(node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:217 + def add_offense_for_missing_location(node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:189 + def add_offense_for_same_line(node, line_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:154 + def check_file(node, file_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:167 + def check_line(node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:95 + def check_location(node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:202 + def expected_line(sign, line_diff); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:122 + def file_and_line(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:177 + def line_difference(line_node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:229 + def missing_line(node, code); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:109 + def register_offense(node, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:114 + def special_file_keyword?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:118 + def special_line_keyword?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:181 + def string_first_line(str_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:127 + def with_binding?(node); end + + # FIXME: It's a Style/ConditionalAssignment's false positive. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:133 + def with_lineno?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:59 +RuboCop::Cop::Style::EvalWithLocation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:60 +RuboCop::Cop::Style::EvalWithLocation::MSG_EVAL = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:61 +RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_FILE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:63 +RuboCop::Cop::Style::EvalWithLocation::MSG_INCORRECT_LINE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/eval_with_location.rb:66 +RuboCop::Cop::Style::EvalWithLocation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where `Integer#even?` or `Integer#odd?` +# can be used. +# +# @example +# +# # bad +# if x % 2 == 0 +# end +# +# # good +# if x.even? +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:18 +class RuboCop::Cop::Style::EvenOdd < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:25 + def even_odd_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:33 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:45 + def replacement_method(arg, method); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:21 +RuboCop::Cop::Style::EvenOdd::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/even_odd.rb:22 +RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for use of the `File.expand_path` arguments. +# Likewise, it also checks for the `Pathname.new` argument. +# +# Contrastive bad case and good case are alternately shown in +# the following examples. +# +# @example +# # bad +# File.expand_path('..', __FILE__) +# +# # good +# File.expand_path(__dir__) +# +# # bad +# File.expand_path('../..', __FILE__) +# +# # good +# File.expand_path('..', __dir__) +# +# # bad +# File.expand_path('.', __FILE__) +# +# # good +# File.expand_path(__FILE__) +# +# # bad +# Pathname(__FILE__).parent.expand_path +# +# # good +# Pathname(__dir__).expand_path +# +# # bad +# Pathname.new(__FILE__).parent.expand_path +# +# # good +# Pathname.new(__dir__).expand_path +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:43 +class RuboCop::Cop::Style::ExpandPathArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:58 + def file_expand_path(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:82 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:74 + def pathname_new_parent_expand_path(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:66 + def pathname_parent_expand_path(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:189 + def arguments_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:100 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:135 + def autocorrect_expand_path(corrector, current_path, default_dir); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:162 + def depth(current_path); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:113 + def inspect_offense_for_expand_path(node, current_path, default_dir); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:168 + def parent_path(current_path); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:182 + def remove_parent_method(corrector, default_dir); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:155 + def strip_surrounded_quotes!(path_string); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:109 + def unrecommended_argument?(default_dir); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:47 +RuboCop::Cop::Style::ExpandPathArguments::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:49 +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:51 +RuboCop::Cop::Style::ExpandPathArguments::PATHNAME_NEW_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/expand_path_arguments.rb:55 +RuboCop::Cop::Style::ExpandPathArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of explicit block argument to avoid writing +# block literal that just passes its arguments to another block. +# +# NOTE: This cop only registers an offense if the block args match the +# yield args exactly. +# +# @example +# # bad +# def with_tmp_dir +# Dir.mktmpdir do |tmp_dir| +# Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments +# end +# end +# +# # bad +# def nine_times +# 9.times { yield } +# end +# +# # good +# def with_tmp_dir(&block) +# Dir.mktmpdir do |tmp_dir| +# Dir.chdir(tmp_dir, &block) +# end +# end +# +# with_tmp_dir do |dir| +# puts "dir is accessible as a parameter and pwd is set: #{dir}" +# end +# +# # good +# def nine_times(&block) +# 9.times(&block) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:41 +class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # @return [ExplicitBlockArgument] a new instance of ExplicitBlockArgument + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:53 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:58 + def on_yield(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:49 + def yielding_block?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:104 + def add_block_argument(node, corrector, block_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:143 + def block_body_range(block_node, send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:121 + def call_like?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:133 + def correct_call_node(node, corrector, block_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:116 + def empty_arguments?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:83 + def extract_block_name(def_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:125 + def insert_argument(node, corrector, block_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:91 + def yielding_arguments?(block_args, yield_args); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/explicit_block_argument.rb:45 +RuboCop::Cop::Style::ExplicitBlockArgument::MSG = T.let(T.unsafe(nil), String) + +# Enforces consistency when using exponential notation +# for numbers in the code (eg 1.2e4). Different styles are supported: +# +# * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive). +# * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa +# to be between 0.1 (inclusive) and 10 (exclusive). +# * `integral` which enforces the mantissa to always be a whole number without +# trailing zeroes. +# +# @example EnforcedStyle: scientific (default) +# # Enforces a mantissa between 1 (inclusive) and 10 (exclusive). +# +# # bad +# 10e6 +# 0.3e4 +# 11.7e5 +# 3.14e0 +# +# # good +# 1e7 +# 3e3 +# 1.17e6 +# 3.14 +# @example EnforcedStyle: engineering +# # Enforces using multiple of 3 exponents, +# # mantissa should be between 0.1 (inclusive) and 1000 (exclusive) +# +# # bad +# 3.2e7 +# 0.1e5 +# 12e5 +# 1232e6 +# +# # good +# 32e6 +# 10e3 +# 1.2e6 +# 1.232e9 +# @example EnforcedStyle: integral +# # Enforces the mantissa to have no decimal part and no +# # trailing zeroes. +# +# # bad +# 3.2e7 +# 0.1e5 +# 120e4 +# +# # good +# 32e6 +# 1e4 +# 12e5 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:60 +class RuboCop::Cop::Style::ExponentialNotation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:68 + def on_float(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:79 + def engineering?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:90 + def integral(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:110 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:95 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:74 + def scientific?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/exponential_notation.rb:62 +RuboCop::Cop::Style::ExponentialNotation::MESSAGES = T.let(T.unsafe(nil), Hash) + +# Suggests `ENV.fetch` for the replacement of `ENV[]`. +# `ENV[]` silently fails and returns `nil` when the environment variable is unset, +# which may cause unexpected behaviors when the developer forgets to set it. +# On the other hand, `ENV.fetch` raises KeyError or returns the explicitly +# specified default value. +# +# @example +# # bad +# ENV['X'] +# x = ENV['X'] +# +# # good +# ENV.fetch('X') +# x = ENV.fetch('X') +# +# # also good +# !ENV['X'] +# ENV['X'].some_method # (e.g. `.nil?`) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:25 +class RuboCop::Cop::Style::FetchEnvVar < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:31 + def env_with_bracket?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:35 + def on_send(node); end + + private + + # The following are allowed cases: + # + # - Used as a flag (e.g., `if ENV['X']` or `!ENV['X']`) because + # it simply checks whether the variable is set. + # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`. + # - `ENV['key']` assigned by logical AND/OR assignment. + # - `ENV['key']` is the LHS of a `||`. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:105 + def allowable_use?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:48 + def allowed_var?(node); end + + # The following are allowed cases: + # + # - `ENV['key']` is a receiver of `||=`, e.g. `ENV['X'] ||= y`. + # - `ENV['key']` is a receiver of `&&=`, e.g. `ENV['X'] &&= y`. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:113 + def assigned?(node); end + + # Check if the node is a receiver and receives a message with dot syntax. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:89 + def message_chained_with_dot?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:126 + def new_code(name_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:84 + def offensive?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:120 + def or_lhs?(node); end + + # Avoid offending in the following cases: + # `ENV['key'] if ENV['key'] = x` + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:80 + def partial_matched?(node, condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:53 + def used_as_flag?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:60 + def used_if_condition_in_body(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:69 + def used_in_condition?(node, condition); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/fetch_env_var.rb:28 +RuboCop::Cop::Style::FetchEnvVar::MSG = T.let(T.unsafe(nil), String) + +# Favor `File.(bin)read` convenience methods. +# +# @example +# ## text mode +# # bad +# File.open(filename).read +# File.open(filename, &:read) +# File.open(filename) { |f| f.read } +# File.open(filename) do |f| +# f.read +# end +# File.open(filename, 'r').read +# File.open(filename, 'r', &:read) +# File.open(filename, 'r') do |f| +# f.read +# end +# +# # good +# File.read(filename) +# @example +# ## binary mode +# # bad +# File.open(filename, 'rb').read +# File.open(filename, 'rb', &:read) +# File.open(filename, 'rb') do |f| +# f.read +# end +# +# # good +# File.binread(filename) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:38 +class RuboCop::Cop::Style::FileRead < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:65 + def block_read?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:49 + def file_open?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:69 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:60 + def send_read?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:84 + def evidence(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:100 + def file_open_read?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:106 + def read_method(mode); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:92 + def read_node?(node, block_pass); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:42 +RuboCop::Cop::Style::FileRead::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:46 +RuboCop::Cop::Style::FileRead::READ_FILE_START_TO_FINISH_MODES = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_read.rb:44 +RuboCop::Cop::Style::FileRead::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Favor `File.(bin)write` convenience methods. +# +# NOTE: There are different method signatures between `File.write` (class method) +# and `File#write` (instance method). The following case will be allowed because +# static analysis does not know the contents of the splat argument: +# +# [source,ruby] +# ---- +# File.open(filename, 'w') do |f| +# f.write(*objects) +# end +# ---- +# +# @example +# ## text mode +# # bad +# File.open(filename, 'w').write(content) +# File.open(filename, 'w') do |f| +# f.write(content) +# end +# +# # good +# File.write(filename, content) +# @example +# ## binary mode +# # bad +# File.open(filename, 'wb').write(content) +# File.open(filename, 'wb') do |f| +# f.write(content) +# end +# +# # good +# File.binwrite(filename, content) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:41 +class RuboCop::Cop::Style::FileWrite < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:68 + def block_write?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:85 + def evidence(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:52 + def file_open?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:72 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:63 + def send_write?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # @yield [content] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:95 + def file_open_write?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:123 + def heredoc?(write_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:128 + def heredoc_range(first_argument); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:108 + def replacement(mode, filename, content, write_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:104 + def write_method(mode); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:45 +RuboCop::Cop::Style::FileWrite::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:47 +RuboCop::Cop::Style::FileWrite::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/file_write.rb:49 +RuboCop::Cop::Style::FileWrite::TRUNCATING_WRITE_MODES = T.let(T.unsafe(nil), Set) + +# Checks for division with integers coerced to floats. +# It is recommended to either always use `fdiv` or coerce one side only. +# This cop also provides other options for code consistency. +# +# @example EnforcedStyle: single_coerce (default) +# # bad +# a.to_f / b.to_f +# +# # good +# a.to_f / b +# a / b.to_f +# @example EnforcedStyle: left_coerce +# # bad +# a / b.to_f +# a.to_f / b.to_f +# +# # good +# a.to_f / b +# @example EnforcedStyle: right_coerce +# # bad +# a.to_f / b +# a.to_f / b.to_f +# +# # good +# a / b.to_f +# @example EnforcedStyle: fdiv +# # bad +# a / b.to_f +# a.to_f / b +# a.to_f / b.to_f +# +# # good +# a.fdiv(b) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:53 +class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:79 + def any_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:75 + def both_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:71 + def left_coerce?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:83 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:67 + def right_coerce?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:121 + def add_to_f_method(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:130 + def correct_from_slash_to_fdiv(corrector, node, receiver, argument); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:141 + def extract_receiver_source(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:117 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:102 + def offense_condition?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:125 + def remove_to_f_method(corrector, send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:57 +RuboCop::Cop::Style::FloatDivision::MESSAGES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/float_division.rb:64 +RuboCop::Cop::Style::FloatDivision::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for uses of the `for` keyword or `each` method. The +# preferred alternative is set in the EnforcedStyle configuration +# parameter. An `each` call with a block on a single line is always +# allowed. +# +# @example EnforcedStyle: each (default) +# # bad +# def foo +# for n in [1, 2, 3] do +# puts n +# end +# end +# +# # good +# def foo +# [1, 2, 3].each do |n| +# puts n +# end +# end +# @example EnforcedStyle: for +# # bad +# def foo +# [1, 2, 3].each do |n| +# puts n +# end +# end +# +# # good +# def foo +# for n in [1, 2, 3] do +# puts n +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:45 +class RuboCop::Cop::Style::For < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:65 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:54 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:65 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:82 + def suspect_enumerable?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:50 +RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:51 +RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/for.rb:52 +RuboCop::Cop::Style::For::PREFER_FOR = T.let(T.unsafe(nil), String) + +# Enforces the use of a single string formatting utility. +# Valid options include Kernel#format, Kernel#sprintf and String#%. +# +# The detection of String#% cannot be implemented in a reliable +# manner for all cases, so only two scenarios are considered - +# if the first argument is a string literal and if the second +# argument is an array literal. +# +# @example EnforcedStyle: format (default) +# # bad +# puts sprintf('%10s', 'hoge') +# puts '%10s' % 'hoge' +# +# # good +# puts format('%10s', 'hoge') +# @example EnforcedStyle: sprintf +# # bad +# puts format('%10s', 'hoge') +# puts '%10s' % 'hoge' +# +# # good +# puts sprintf('%10s', 'hoge') +# @example EnforcedStyle: percent +# # bad +# puts format('%10s', 'hoge') +# puts sprintf('%10s', 'hoge') +# +# # good +# puts '%10s' % 'hoge' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:38 +class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:46 + def formatter(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:59 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:55 + def variable_argument?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:81 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:97 + def autocorrect_from_percent(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:111 + def autocorrect_to_percent(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:124 + def format_single_parameter(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:73 + def message(detected_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:77 + def method_name(style_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:42 +RuboCop::Cop::Style::FormatString::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/format_string.rb:43 +RuboCop::Cop::Style::FormatString::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Use a consistent style for named format string tokens. +# +# NOTE: `unannotated` style cop only works for strings +# which are passed as arguments to those methods: +# `printf`, `sprintf`, `format`, `%`. +# The reason is that _unannotated_ format is very similar +# to encoded URLs or Date/Time formatting strings. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# It is allowed to contain unannotated token +# if the number of them is less than or equals to +# `MaxUnannotatedPlaceholdersAllowed`. +# +# @example AllowedPatterns: [/redirect/] +# +# # good +# redirect('foo/%{bar_id}') +# @example EnforcedStyle: template +# +# # bad +# format('%<greeting>s', greeting: 'Hello') +# format('%s', 'Hello') +# +# # good +# format('%{greeting}', greeting: 'Hello') +# @example EnforcedStyle: unannotated +# +# # bad +# format('%<greeting>s', greeting: 'Hello') +# format('%{greeting}', greeting: 'Hello') +# +# # good +# format('%s', 'Hello') +# @example MaxUnannotatedPlaceholdersAllowed: 0 +# +# # bad +# format('%06d', 10) +# format('%s %s.', 'Hello', 'world') +# +# # good +# format('%<number>06d', number: 10) +# @example MaxUnannotatedPlaceholdersAllowed: 1 (default) +# +# # bad +# format('%s %s.', 'Hello', 'world') +# +# # good +# format('%06d', 10) +# @example AllowedMethods: [] (default) +# +# # bad +# redirect('foo/%{bar_id}') +# @example AllowedMethods: [redirect] +# +# # good +# redirect('foo/%{bar_id}') +# @example AllowedPatterns: [] (default) +# +# # bad +# redirect('foo/%{bar_id}') +# @example EnforcedStyle: annotated (default) +# +# # bad +# format('%{greeting}', greeting: 'Hello') +# format('%s', 'Hello') +# +# # good +# format('%<greeting>s', greeting: 'Hello') +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:85 +class RuboCop::Cop::Style::FormatStringToken < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:106 + def format_string_in_typical_context?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:91 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:213 + def allowed_unannotated?(detections); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:139 + def autocorrect_sequence(corrector, detected_sequence, token_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:124 + def check_sequence(detected_sequence, token_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:203 + def collect_detections(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:135 + def correctable_sequence?(detected_type); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:113 + def format_string_token?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:222 + def max_unannotated_placeholders_allowed; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:160 + def message(detected_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:165 + def message_text(style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:180 + def str_contents(source_map); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:190 + def token_ranges(contents); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:174 + def tokens(str_node, &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:156 + def unannotated_format?(node, detected_style); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/format_string_token.rb:117 + def use_allowed_method?(node); end +end + +# Helps you transition from mutable string literals +# to frozen string literals. +# of files to enable frozen string literals. Frozen string literals may be +# default in future Ruby. The comment will be added below a shebang and +# encoding comment. The frozen string literal comment is only valid in Ruby 2.3+. +# +# Note that the cop will accept files where the comment exists but is set +# to `false` instead of `true`. +# +# To require a blank line after this comment, please see +# `Layout/EmptyLineAfterMagicComment` cop. +# +# @example EnforcedStyle: always (default) +# # The `always` style will always add the frozen string literal comment +# # to a file, regardless of the Ruby version or if `freeze` or `<<` are +# # called on a string literal. +# # bad +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: true +# +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: false +# +# module Bar +# # ... +# end +# @example EnforcedStyle: never +# # The `never` will enforce that the frozen string literal comment does +# # not exist in a file. +# # bad +# # frozen_string_literal: true +# +# module Baz +# # ... +# end +# +# # good +# module Baz +# # ... +# end +# @example EnforcedStyle: always_true +# # The `always_true` style enforces that the frozen string literal +# # comment is set to `true`. This is a stricter option than `always` +# # and forces projects to use frozen string literals. +# # bad +# # frozen_string_literal: false +# +# module Baz +# # ... +# end +# +# # bad +# module Baz +# # ... +# end +# +# # good +# # frozen_string_literal: true +# +# module Bar +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:84 +class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:99 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:176 + def disabled_offense(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:188 + def enable_comment(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:120 + def ensure_comment(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:126 + def ensure_enabled_comment(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:114 + def ensure_no_comment(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:212 + def following_comment; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:150 + def frozen_string_literal_comment(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:194 + def insert_comment(corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:137 + def last_special_comment(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:204 + def line_range(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:156 + def missing_offense(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:162 + def missing_true_offense(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:208 + def preceding_comment; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:184 + def remove_comment(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:168 + def unnecessary_comment_offense(processed_source); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:96 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_DISABLED = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:94 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:93 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_MISSING_TRUE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:95 +RuboCop::Cop::Style::FrozenStringLiteralComment::MSG_UNNECESSARY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/frozen_string_literal_comment.rb:97 +RuboCop::Cop::Style::FrozenStringLiteralComment::SHEBANG = T.let(T.unsafe(nil), String) + +# Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`. +# `STDOUT/STDERR/STDIN` are constants, and while you can actually +# reassign (possibly to redirect some stream) constants in Ruby, you'll get +# an interpreter warning if you do so. +# +# @example +# # bad +# STDOUT.puts('hello') +# +# hash = { out: STDOUT, key: value } +# +# def m(out = STDOUT) +# out.puts('hello') +# end +# +# # good +# $stdout.puts('hello') +# +# hash = { out: $stdout, key: value } +# +# def m(out = $stdout) +# out.puts('hello') +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:34 +class RuboCop::Cop::Style::GlobalStdStream < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:42 + def const_to_gvar_assignment?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:46 + def on_const(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:64 + def gvar_name(const_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:60 + def message(const_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:37 +RuboCop::Cop::Style::GlobalStdStream::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_std_stream.rb:39 +RuboCop::Cop::Style::GlobalStdStream::STD_STREAMS = T.let(T.unsafe(nil), Set) + +# Looks for uses of global variables. +# It does not report offenses for built-in global variables. +# Built-in global variables are allowed by default. Additionally +# users can allow additional variables via the AllowedVariables option. +# +# Note that backreferences like $1, $2, etc are not global variables. +# +# @example +# # bad +# $foo = 2 +# bar = $foo + 5 +# +# # good +# FOO = 2 +# foo = 2 +# $stdin.read +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:22 +class RuboCop::Cop::Style::GlobalVars < ::RuboCop::Cop::Base + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:60 + def allowed_var?(global_var); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:72 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:64 + def on_gvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:68 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:56 + def user_vars; end +end + +# built-in global variables and their English aliases +# https://www.zenspider.com/ruby/quickref.html +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:27 +RuboCop::Cop::Style::GlobalVars::BUILT_IN_VARS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/global_vars.rb:23 +RuboCop::Cop::Style::GlobalVars::MSG = T.let(T.unsafe(nil), String) + +# Use a guard clause instead of wrapping the code inside a conditional +# expression +# +# A condition with an `elsif` or `else` branch is allowed unless +# one of `return`, `break`, `next`, `raise`, or `fail` is used +# in the body of the conditional expression. +# +# @example +# # bad +# def test +# if something +# work +# end +# end +# +# # good +# def test +# return unless something +# +# work +# end +# +# # also good +# def test +# work if something +# end +# +# # bad +# if something +# raise 'exception' +# else +# ok +# end +# +# # good +# raise 'exception' if something +# ok +# +# # bad +# if something +# foo || raise('exception') +# else +# ok +# end +# +# # good +# foo || raise('exception') if something +# ok +# @example AllowConsecutiveConditionals: false (default) +# # bad +# def test +# if foo? +# work +# end +# +# if bar? # <- reports an offense +# work +# end +# end +# @example AllowConsecutiveConditionals: true +# # good +# def test +# if foo? +# work +# end +# +# if bar? +# work +# end +# end +# +# # bad +# def test +# if foo? +# work +# end +# +# do_something +# +# if bar? # <- reports an offense +# work +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:92 +class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::StatementModifier + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:99 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:99 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:113 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:175 + def accepted_form?(node, ending: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:183 + def accepted_if?(node, ending); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:193 + def allowed_consecutive_conditionals?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:132 + def check_ending_if(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:140 + def consecutive_conditionals?(parent, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:160 + def guard_clause_source(guard_clause); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:148 + def register_offense(node, scope_exiting_keyword, conditional_keyword); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:170 + def too_long_for_single_line?(node, example); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:179 + def trivial?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/guard_clause.rb:96 +RuboCop::Cop::Style::GuardClause::MSG = T.let(T.unsafe(nil), String) + +# Checks for presence or absence of braces around hash literal as a last +# array item depending on configuration. +# +# NOTE: This cop will ignore arrays where all items are hashes, regardless of +# EnforcedStyle. +# +# @example EnforcedStyle: braces (default) +# # bad +# [1, 2, one: 1, two: 2] +# +# # good +# [1, 2, { one: 1, two: 2 }] +# +# # good +# [{ one: 1 }, { two: 2 }] +# @example EnforcedStyle: no_braces +# # bad +# [1, 2, { one: 1, two: 2 }] +# +# # good +# [1, 2, one: 1, two: 2] +# +# # good +# [{ one: 1 }, { two: 2 }] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:31 +class RuboCop::Cop::Style::HashAsLastArrayItem < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:36 + def on_hash(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:84 + def braces_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:65 + def check_braces(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:73 + def check_no_braces(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:49 + def containing_array(hash_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:60 + def explicit_array?(array); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:54 + def last_array_item?(array, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_as_last_array_item.rb:88 + def remove_last_element_trailing_comma(corrector, node); end +end + +# Checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and +# sequences of values to hashes. +# +# Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example, +# `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated. +# So, `AllowSplatArgument` option is true by default to allow splat argument for simple code. +# +# @example +# # bad +# Hash[ary] +# +# # good +# ary.to_h +# +# # bad +# Hash[key1, value1, key2, value2] +# +# # good +# {key1 => value1, key2 => value2} +# @example AllowSplatArgument: true (default) +# # good +# Hash[*ary] +# @example AllowSplatArgument: false +# # bad +# Hash[*ary] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:34 +class RuboCop::Cop::Style::HashConversion < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:44 + def hash_from_array?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:46 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:128 + def allowed_splat_argument?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:121 + def args_to_hash(args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:108 + def multi_argument(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:84 + def register_offense_for_hash(node, hash_argument); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:93 + def register_offense_for_zip_method(node, zip_method); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:103 + def requires_parens?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:61 + def single_argument(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:78 + def use_zip_method_without_argument?(first_argument); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:39 +RuboCop::Cop::Style::HashConversion::MSG_LITERAL_HASH_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:38 +RuboCop::Cop::Style::HashConversion::MSG_LITERAL_MULTI_ARG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:40 +RuboCop::Cop::Style::HashConversion::MSG_SPLAT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:37 +RuboCop::Cop::Style::HashConversion::MSG_TO_H = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_conversion.rb:41 +RuboCop::Cop::Style::HashConversion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `each_key` and `each_value` Hash methods. +# +# NOTE: If you have an array of two-element arrays, you can put +# parentheses around the block arguments to indicate that you're not +# working with a hash, and suppress RuboCop offenses. +# +# @example +# # bad +# hash.keys.each { |k| p k } +# hash.values.each { |v| p v } +# +# # good +# hash.each_key { |k| p k } +# hash.each_value { |v| p v } +# @example AllowedReceivers: ['execute'] +# # good +# execute(sql).keys.each { |v| p v } +# execute(sql).values.each { |v| p v } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:30 +class RuboCop::Cop::Style::HashEachMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:37 + def kv_each(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:41 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:41 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:98 + def allowed_receiver?(receiver); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:104 + def allowed_receivers; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:63 + def check_argument(variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:87 + def correct_args(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:73 + def correct_implicit(node, corrector, method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:78 + def correct_key_value_each(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:94 + def kv_range(outer_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:49 + def register_kv_offense(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:69 + def used?(arg); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_each_methods.rb:34 +RuboCop::Cop::Style::HashEachMethods::MSG = T.let(T.unsafe(nil), String) + +# Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods +# that can be replaced with `Hash#except` method. +# +# This cop should only be enabled on Ruby version 3.0 or higher. +# (`Hash#except` was added in Ruby 3.0.) +# +# For safe detection, it is limited to commonly used string and symbol comparisons +# when used `==`. +# And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object. +# +# @example +# +# # bad +# {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar } +# {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar } +# {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar } +# {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[foo bar].include?(k) } +# {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[foo bar].include?(k) } +# {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[foo bar].include?(k) } +# +# # good +# {foo: 1, bar: 2, baz: 3}.except(:bar) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:29 +class RuboCop::Cop::Style::HashExcept < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::TargetRubyVersion + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:56 + def bad_method_with_active_support?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:40 + def bad_method_with_poro?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:71 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:88 + def bad_method?(block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:150 + def decorate_source(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:158 + def except_key(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:137 + def except_key_source(key); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:131 + def extract_body_if_nagated(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:112 + def included?(negated, body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:116 + def not_included?(negated, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:167 + def offense_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:120 + def safe_to_register_offense?(block, except_key); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:96 + def semantically_except_method?(send, block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:36 +RuboCop::Cop::Style::HashExcept::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_except.rb:37 +RuboCop::Cop::Style::HashExcept::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where `case-when` represents a simple 1:1 +# mapping and can be replaced with a hash lookup. +# +# @example MinBranchesCount: 3 (default) +# # bad +# case country +# when 'europe' +# 'http://eu.example.com' +# when 'america' +# 'http://us.example.com' +# when 'australia' +# 'http://au.example.com' +# end +# +# # good +# SITES = { +# 'europe' => 'http://eu.example.com', +# 'america' => 'http://us.example.com', +# 'australia' => 'http://au.example.com' +# } +# SITES[country] +# @example MinBranchesCount: 4 +# # good +# case country +# when 'europe' +# 'http://eu.example.com' +# when 'america' +# 'http://us.example.com' +# when 'australia' +# 'http://au.example.com' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:39 +class RuboCop::Cop::Style::HashLikeCase < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:43 + def hash_like_case?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:51 + def on_case(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:67 + def min_branches_count; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:63 + def nodes_of_same_type?(nodes); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_like_case.rb:40 +RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) + +# Checks hash literal syntax. +# +# It can enforce either the use of the class hash rocket syntax or +# the use of the newer Ruby 1.9 syntax (when applicable). +# +# A separate offense is registered for each problematic pair. +# +# The supported styles are: +# +# * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have +# all symbols for keys +# * hash_rockets - forces use of hash rockets for all hashes +# * no_mixed_keys - simply checks for hashes with mixed syntaxes +# * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed +# syntax hashes +# +# This cop has `EnforcedShorthandSyntax` option. +# It can enforce either the use of the explicit hash value syntax or +# the use of Ruby 3.1's hash value shorthand syntax. +# +# The supported styles are: +# +# * always - forces use of the 3.1 syntax (e.g. {foo:}) +# * never - forces use of explicit hash literal value +# * either - accepts both shorthand and explicit use of hash literal value +# * consistent - like "always", but will avoid mixing styles in a single hash +# +# @example EnforcedShorthandSyntax: consistent +# +# # bad +# {foo: , bar: bar} +# +# # good +# {foo:, bar:} +# +# # bad +# {foo: , bar: baz} +# +# # good +# {foo: foo, bar: baz} +# @example EnforcedStyle: hash_rockets +# # bad +# {a: 1, b: 2} +# {c: 1, 'd' => 5} +# +# # good +# {:a => 1, :b => 2} +# @example EnforcedStyle: no_mixed_keys +# # bad +# {:a => 1, b: 2} +# {c: 1, 'd' => 2} +# +# # good +# {:a => 1, :b => 2} +# {c: 1, d: 2} +# @example EnforcedStyle: ruby19_no_mixed_keys +# # bad +# {:a => 1, :b => 2} +# {c: 2, 'd' => 3} # should just use hash rockets +# +# # good +# {a: 1, b: 2} +# {:c => 3, 'd' => 4} +# @example EnforcedShorthandSyntax: always (default) +# +# # bad +# {foo: foo, bar: bar} +# +# # good +# {foo:, bar:} +# @example EnforcedShorthandSyntax: never +# +# # bad +# {foo:, bar:} +# +# # good +# {foo: foo, bar: bar} +# @example EnforcedShorthandSyntax: either +# +# # good +# {foo: foo, bar: bar} +# +# # good +# {foo:, bar:} +# @example EnforcedStyle: ruby19 (default) +# # bad +# {:a => 2} +# {b: 1, :c => 2} +# +# # good +# {a: 2, b: 1} +# {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol +# {d: 1, 'e' => 2} # technically not forbidden +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:107 +class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::HashShorthandSyntax + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:161 + def alternative_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:139 + def hash_rockets_check(pairs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:153 + def no_mixed_keys_check(pairs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:117 + def on_hash(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:135 + def ruby19_check(pairs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:143 + def ruby19_no_mixed_keys_check(pairs); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:192 + def acceptable_19_syntax_symbol?(sym_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:246 + def argument_without_space?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:172 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:250 + def autocorrect_hash_rockets(corrector, pair_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:258 + def autocorrect_no_mixed_keys(corrector, pair_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:225 + def autocorrect_ruby19(corrector, pair_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:210 + def check(pairs, delim, msg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:266 + def force_hash_rockets?(pairs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:238 + def range_for_autocorrect_ruby19(pair_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:182 + def sym_indices?(pairs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:186 + def word_symbol_pair?(pair); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:113 +RuboCop::Cop::Style::HashSyntax::MSG_19 = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:115 +RuboCop::Cop::Style::HashSyntax::MSG_HASH_ROCKETS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_syntax.rb:114 +RuboCop::Cop::Style::HashSyntax::MSG_NO_MIXED_KEYS = T.let(T.unsafe(nil), String) + +# Looks for uses of `_.each_with_object({}) {...}`, +# `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just +# transforming the keys of a hash, and tries to use a simpler & faster +# call to `transform_keys` instead. +# It should only be enabled on Ruby version 2.5 or newer. +# (`transform_keys` was added in Ruby 2.5.) +# +# @example +# # bad +# {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v } +# Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }] +# {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h +# {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] } +# +# # good +# {a: 1, b: 2}.transform_keys { |k| foo(k) } +# {a: 1, b: 2}.transform_keys { |k| k.to_s } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:28 +class RuboCop::Cop::Style::HashTransformKeys < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashTransformMethod + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:36 + def on_bad_each_with_object(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:48 + def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:61 + def on_bad_map_to_h(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:73 + def on_bad_to_h(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:84 + def extract_captures(match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_keys.rb:89 + def new_method_name; end +end + +# Looks for uses of `_.each_with_object({}) {...}`, +# `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just +# transforming the values of a hash, and tries to use a simpler & faster +# call to `transform_values` instead. +# +# @example +# # bad +# {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) } +# Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }] +# {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h +# {a: 1, b: 2}.to_h { |k, v| [k, v * v] } +# +# # good +# {a: 1, b: 2}.transform_values { |v| foo(v) } +# {a: 1, b: 2}.transform_values { |v| v * v } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:26 +class RuboCop::Cop::Style::HashTransformValues < ::RuboCop::Cop::Base + include ::RuboCop::Cop::HashTransformMethod + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:34 + def on_bad_each_with_object(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:46 + def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:59 + def on_bad_map_to_h(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:71 + def on_bad_to_h(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:82 + def extract_captures(match); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/hash_transform_values.rb:87 + def new_method_name; end +end + +# Checks for identical expressions at the beginning or end of +# each branch of a conditional expression. Such expressions should normally +# be placed outside the conditional expression - before or after it. +# +# NOTE: The cop is poorly named and some people might think that it actually +# checks for duplicated conditional branches. The name will probably be changed +# in a future major RuboCop release. +# +# @example +# # bad +# if condition +# do_x +# do_z +# else +# do_y +# do_z +# end +# +# # good +# if condition +# do_x +# else +# do_y +# end +# do_z +# +# # bad +# if condition +# do_z +# do_x +# else +# do_z +# do_y +# end +# +# # good +# do_z +# if condition +# do_x +# else +# do_y +# end +# +# # bad +# case foo +# when 1 +# do_x +# when 2 +# do_x +# else +# do_x +# end +# +# # good +# case foo +# when 1 +# do_x +# do_y +# when 2 +# # nothing +# else +# do_x +# do_z +# end +# +# # bad +# case foo +# in 1 +# do_x +# in 2 +# do_x +# else +# do_x +# end +# +# # good +# case foo +# in 1 +# do_x +# do_y +# in 2 +# # nothing +# else +# do_x +# do_z +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:110 +class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:123 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:130 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:116 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:139 + def check_branches(node, branches); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:162 + def check_expressions(node, expressions, insert_position); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:151 + def duplicated_expressions?(node, expressions); end + + # `elsif` branches show up in the if node as nested `else` branches. We + # need to recursively iterate over all `else` branches. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:189 + def expand_elses(branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:204 + def head(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:183 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:200 + def tail(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/identical_conditional_branches.rb:114 +RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), String) + +# Corrector to correct conditional assignment in `if` statements. +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:564 +class RuboCop::Cop::Style::IfCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:569 + def correct(corrector, cop, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:573 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:587 + def extract_tail_branches(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:594 + def move_branch_inside_condition(corrector, branch, condition, assignment, column); end + end +end + +# If the `else` branch of a conditional consists solely of an `if` node, +# it can be combined with the `else` to become an `elsif`. +# This helps to keep the nesting level from getting too deep. +# +# @example +# # bad +# if condition_a +# action_a +# else +# if condition_b +# action_b +# else +# action_c +# end +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# else +# action_c +# end +# @example AllowIfModifier: false (default) +# # bad +# if condition_a +# action_a +# else +# action_b if condition_b +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# end +# @example AllowIfModifier: true +# # good +# if condition_a +# action_a +# else +# action_b if condition_b +# end +# +# # good +# if condition_a +# action_a +# elsif condition_b +# action_b +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:61 +class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:67 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:144 + def allow_if_modifier?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:140 + def allow_if_modifier_in_else_branch?(else_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:82 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:111 + def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:103 + def correct_to_elsif_from_modifier_form(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:129 + def find_end_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:136 + def if_condition_range(node, condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:125 + def then?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_inside_else.rb:65 +RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for `if` and `unless` statements that would fit on one line if +# written as modifier `if`/`unless`. The cop also checks for modifier +# `if`/`unless` lines that exceed the maximum line length. +# +# The maximum line length is configured in the `Layout/LineLength` +# cop. The tab size is configured in the `IndentationWidth` of the +# `Layout/IndentationStyle` cop. +# +# @example +# # bad +# if condition +# do_stuff(bar) +# end +# +# unless qux.empty? +# Foo.do_something +# end +# +# do_something_with_a_long_name(arg) if long_condition_that_prevents_code_fit_on_single_line +# +# # good +# do_stuff(bar) if condition +# Foo.do_something unless qux.empty? +# +# if long_condition_that_prevents_code_fit_on_single_line +# do_something_with_a_long_name(arg) +# end +# +# if short_condition # a long comment that makes it too long if it were just a single line +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:37 +class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:53 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:90 + def allowed_patterns; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:150 + def another_statement_on_same_line?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:68 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:184 + def extract_heredoc_from(last_argument); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:134 + def line_length_enabled_at_line?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:138 + def named_capture_in_condition?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:142 + def non_eligible_node?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:146 + def non_simple_if_unless?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:191 + def remove_heredoc(corrector, heredoc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:164 + def to_normal_form(node, indentation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:172 + def to_normal_form_with_heredoc(node, indentation, heredoc); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:85 + def too_long_due_to_modifier?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:125 + def too_long_line_based_on_allow_uri?(line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:108 + def too_long_line_based_on_config?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:117 + def too_long_line_based_on_ignore_cop_directives?(range, line); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:95 + def too_long_single_line?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:49 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:44 +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier.rb:47 +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) + +# Checks for if and unless statements used as modifiers of other if or +# unless statements. +# +# @example +# +# # bad +# tired? ? 'stop' : 'go faster' if running? +# +# # bad +# if tired? +# "please stop" +# else +# "keep going" +# end if running? +# +# # good +# if running? +# tired? ? 'stop' : 'go faster' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:25 +class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:31 + def on_if(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:29 +RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant `if` with boolean literal branches. +# It checks only conditions to return boolean value (`true` or `false`) for safe detection. +# The conditions to be checked are comparison methods, predicate methods, and double negative. +# `nonzero?` method is allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# if foo == bar +# true +# else +# false +# end +# +# # bad +# foo == bar ? true : false +# +# # good +# foo == bar +# @example +# # bad +# if foo.do_something? +# true +# else +# false +# end +# +# # good (but potentially an unsafe correction) +# foo.do_something? +# @example AllowedMethods: ['nonzero?'] (default) +# # good +# num.nonzero? ? true : false +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:45 +class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:57 + def double_negative?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:53 + def if_with_boolean_literal_branches?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:59 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:109 + def assume_boolean_value?(condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:91 + def message(node, keyword); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:79 + def offense_range_with_keyword(node, condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:126 + def opposite_condition?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:116 + def replacement_condition(node, condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:131 + def require_parentheses?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:97 + def return_boolean_value?(condition); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:49 +RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:50 +RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG_FOR_ELSIF = T.let(T.unsafe(nil), String) + +# Checks for uses of semicolon in if statements. +# +# @example +# +# # bad +# result = if some_condition; something else another_thing end +# +# # good +# result = some_condition ? something : another_thing +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:16 +class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:23 + def on_normal_if_unless(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:39 + def autocorrect(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:56 + def build_else_branch(second_condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:47 + def correct_elsif(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:20 +RuboCop::Cop::Style::IfWithSemicolon::MSG_IF_ELSE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/if_with_semicolon.rb:21 +RuboCop::Cop::Style::IfWithSemicolon::MSG_TERNARY = T.let(T.unsafe(nil), String) + +# Checks for `raise` or `fail` statements which do not specify an +# explicit exception class. (This raises a `RuntimeError`. Some projects +# might prefer to use exception classes which more precisely identify the +# nature of the error.) +# +# @example +# # bad +# raise 'Error message here' +# +# # good +# raise ArgumentError, 'Error message here' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/implicit_runtime_error.rb:17 +class RuboCop::Cop::Style::ImplicitRuntimeError < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/implicit_runtime_error.rb:23 + def implicit_runtime_error_raise_or_fail(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/implicit_runtime_error.rb:26 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/implicit_runtime_error.rb:18 +RuboCop::Cop::Style::ImplicitRuntimeError::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/implicit_runtime_error.rb:20 +RuboCop::Cop::Style::ImplicitRuntimeError::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `in;` uses in `case` expressions. +# +# @example +# # bad +# case expression +# in pattern_a; foo +# in pattern_b; bar +# end +# +# # good +# case expression +# in pattern_a then foo +# in pattern_b then bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/in_pattern_then.rb:21 +class RuboCop::Cop::Style::InPatternThen < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/in_pattern_then.rb:29 + def on_in_pattern(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/in_pattern_then.rb:46 + def alternative_pattern_source(pattern); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/in_pattern_then.rb:27 +RuboCop::Cop::Style::InPatternThen::MSG = T.let(T.unsafe(nil), String) + +# Use `Kernel#loop` for infinite loops. +# +# @example +# # bad +# while true +# work +# end +# +# # good +# loop do +# work +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:23 +class RuboCop::Cop::Style::InfiniteLoop < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:34 + def after_leaving_scope(scope, _variable_table); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:43 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:43 + def on_until_post(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:39 + def on_while(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:39 + def on_while_post(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:83 + def assigned_before_loop?(var, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:79 + def assigned_inside_loop?(var, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:69 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:124 + def configured_indent; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:102 + def modifier_replacement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:113 + def non_modifier_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:88 + def referenced_after_loop?(var, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:93 + def replace_begin_end_with_modifier(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:98 + def replace_source(corrector, range, replacement); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:52 + def while_or_until(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:30 + def joining_forces; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:26 +RuboCop::Cop::Style::InfiniteLoop::LEADING_SPACE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/infinite_loop.rb:28 +RuboCop::Cop::Style::InfiniteLoop::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing inline comments. +# +# @example +# +# # good +# foo.each do |f| +# # Standalone comment +# f.bar +# end +# +# # bad +# foo.each do |f| +# f.bar # Trailing inline comment +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/inline_comment.rb:20 +class RuboCop::Cop::Style::InlineComment < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/inline_comment.rb:23 + def on_new_investigation; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inline_comment.rb:21 +RuboCop::Cop::Style::InlineComment::MSG = T.let(T.unsafe(nil), String) + +# Check for usages of not (`not` or `!`) called on a method +# when an inverse of that method can be used instead. +# +# Methods that can be inverted by a not (`not` or `!`) should be defined +# in `InverseMethods`. +# +# Methods that are inverted by inverting the return +# of the block that is passed to the method should be defined in +# `InverseBlocks`. +# +# @example +# # bad +# !foo.none? +# !foo.any? { |f| f.even? } +# !foo.blank? +# !(foo == bar) +# foo.select { |f| !f.even? } +# foo.reject { |f| f != 7 } +# +# # good +# foo.none? +# foo.blank? +# foo.any? { |f| f.even? } +# foo != bar +# foo == bar +# !!('foo' =~ /^\w+$/) +# !(foo.class < Numeric) # Checking class hierarchy is allowed +# # Blocks with guard clauses are ignored: +# foo.select do |f| +# next if f.zero? +# f != 1 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:43 +class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:68 + def inverse_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:59 + def inverse_candidate?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:89 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:89 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:76 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:174 + def camel_case_constant?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:118 + def correct_inverse_block(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:109 + def correct_inverse_method(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:125 + def correct_inverse_selector(block, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:178 + def dot_range(loc); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:161 + def end_parentheses(node, method_call); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:147 + def inverse_blocks; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:142 + def inverse_methods; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:188 + def message(method, inverse); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:151 + def negated?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:155 + def not_to_receiver(node, method_call); end + + # When comparing classes, `!(Integer < Numeric)` is not the same as + # `Integer > Numeric`. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:169 + def possible_class_hierarchy_check?(lhs, rhs, method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:182 + def remove_end_parenthesis(corrector, node, method, method_call); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:54 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:52 +RuboCop::Cop::Style::InverseMethods::CAMEL_CASE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:49 +RuboCop::Cop::Style::InverseMethods::CLASS_COMPARISON_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:50 +RuboCop::Cop::Style::InverseMethods::EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:48 +RuboCop::Cop::Style::InverseMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/inverse_methods.rb:51 +RuboCop::Cop::Style::InverseMethods::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for hardcoded IP addresses, which can make code +# brittle. IP addresses are likely to need to be changed when code +# is deployed to a different server or environment, which may break +# a deployment if forgotten. Prefer setting IP addresses in ENV or +# other configuration. +# +# @example +# +# # bad +# ip_address = '127.59.241.29' +# +# # good +# ip_address = ENV['DEPLOYMENT_IP_ADDRESS'] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:21 +class RuboCop::Cop::Style::IpAddresses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::StringHelp + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:46 + def correct_style_detected; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:27 + def offense?(node); end + + # Dummy implementation of method in ConfigurableEnforcedStyle that is + # called from StringHelp. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:42 + def opposite_style_detected; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:50 + def allowed_addresses; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:55 + def could_be_ip?(str); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:68 + def starts_with_hex_or_colon?(str); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:64 + def too_long?(str); end +end + +# IPv4-mapped IPv6 is the longest +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:24 +RuboCop::Cop::Style::IpAddresses::IPV6_MAX_SIZE = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ip_addresses.rb:25 +RuboCop::Cop::Style::IpAddresses::MSG = T.let(T.unsafe(nil), String) + +# Enforces that optional keyword parameters are placed at the +# end of the parameters list. +# +# This improves readability, because when looking through the source, +# it is expected to find required parameters at the beginning of parameters list +# and optional parameters at the end. +# +# @example +# # bad +# def some_method(first: false, second:, third: 10) +# # body omitted +# end +# +# # good +# def some_method(second:, first: false, third: 10) +# # body omitted +# end +# +# # bad +# do_something do |first: false, second:, third: 10| +# # body omitted +# end +# +# # good +# do_something do |second:, first: false, third: 10| +# # body omitted +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/keyword_parameters_order.rb:34 +class RuboCop::Cop::Style::KeywordParametersOrder < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/keyword_parameters_order.rb:40 + def on_kwoptarg(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/keyword_parameters_order.rb:58 + def append_newline_to_last_kwoptarg(arguments, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/keyword_parameters_order.rb:66 + def remove_kwargs(kwarg_nodes, corrector); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/keyword_parameters_order.rb:38 +RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String) + +# (by default) checks for uses of the lambda literal syntax for +# single line lambdas, and the method call syntax for multiline lambdas. +# It is configurable to enforce one of the styles for both single line +# and multiline lambdas as well. +# +# @example EnforcedStyle: line_count_dependent (default) +# # bad +# f = lambda { |x| x } +# f = ->(x) do +# x +# end +# +# # good +# f = ->(x) { x } +# f = lambda do |x| +# x +# end +# @example EnforcedStyle: lambda +# # bad +# f = ->(x) { x } +# f = ->(x) do +# x +# end +# +# # good +# f = lambda { |x| x } +# f = lambda do |x| +# x +# end +# @example EnforcedStyle: literal +# # bad +# f = lambda { |x| x } +# f = lambda do |x| +# x +# end +# +# # good +# f = ->(x) { x } +# f = ->(x) do +# x +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:49 +class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:64 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:64 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:115 + def arguments_with_whitespace(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:104 + def autocorrect_method_to_literal(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:119 + def lambda_arg_string(args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:89 + def message(node, selector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:95 + def message_line_modifier(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:83 + def offending_selector?(node, selector); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:53 +RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:54 +RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda.rb:56 +RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +# Checks for use of the lambda.(args) syntax. +# +# @example EnforcedStyle: call (default) +# # bad +# lambda.(x, y) +# +# # good +# lambda.call(x, y) +# @example EnforcedStyle: braces +# # bad +# lambda.call(x, y) +# +# # good +# lambda.(x, y) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:21 +class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:28 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:62 + def explicit_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:58 + def implicit_style?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:46 + def offense?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:50 + def prefer(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:25 +RuboCop::Cop::Style::LambdaCall::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/lambda_call.rb:26 +RuboCop::Cop::Style::LambdaCall::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for string literal concatenation at +# the end of a line. +# +# @example +# +# # bad +# some_str = 'ala' + +# 'bala' +# +# some_str = 'ala' << +# 'bala' +# +# # good +# some_str = 'ala' \ +# 'bala' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:35 +class RuboCop::Cop::Style::LineEndConcatenation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:51 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:71 + def autocorrect(corrector, operator_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:57 + def check_token_set(index); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:98 + def eligible_next_successor?(next_successor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:94 + def eligible_operator?(operator); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:102 + def eligible_predecessor?(predecessor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:90 + def eligible_successor?(successor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:84 + def eligible_token_set?(predecessor, operator, successor); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:121 + def standard_string_literal?(token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:106 + def token_after_last_string(successor, base_index); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:47 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:42 +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_BEGIN_TOKEN = T.let(T.unsafe(nil), Symbol) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:43 +RuboCop::Cop::Style::LineEndConcatenation::COMPLEX_STRING_END_TOKEN = T.let(T.unsafe(nil), Symbol) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:40 +RuboCop::Cop::Style::LineEndConcatenation::CONCAT_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:44 +RuboCop::Cop::Style::LineEndConcatenation::HIGH_PRECEDENCE_OP_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:39 +RuboCop::Cop::Style::LineEndConcatenation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:45 +RuboCop::Cop::Style::LineEndConcatenation::QUOTE_DELIMITERS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/line_end_concatenation.rb:41 +RuboCop::Cop::Style::LineEndConcatenation::SIMPLE_STRING_TOKEN_TYPE = T.let(T.unsafe(nil), Symbol) + +# Ensures magic comments are written consistently throughout your code base. +# Looks for discrepancies in separators (`-` vs `_`) and capitalization for +# both magic comment directives and values. +# +# Required capitalization can be set with the `DirectiveCapitalization` and +# `ValueCapitalization` configuration keys. +# +# NOTE: If one of these configuration is set to nil, any capitalization is allowed. +# +# @example ValueCapitalization: uppercase +# # bad +# # frozen-string-literal: true +# +# # good +# # frozen-string-literal: TRUE +# @example EnforcedStyle: kebab_case +# # The `kebab_case` style will enforce that the frozen string literal +# # comment is written in kebab case. (Words separated by hyphens) +# # bad +# # frozen_string_literal: true +# +# module Baz +# # ... +# end +# +# # good +# # frozen-string-literal: true +# +# module Baz +# # ... +# end +# @example DirectiveCapitalization: lowercase (default) +# # bad +# # FROZEN-STRING-LITERAL: true +# +# # good +# # frozen-string-literal: true +# @example DirectiveCapitalization: uppercase +# # bad +# # frozen-string-literal: true +# +# # good +# # FROZEN-STRING-LITERAL: true +# @example DirectiveCapitalization: nil +# # any capitalization is accepted +# +# # good +# # frozen-string-literal: true +# +# # good +# # FROZEN-STRING-LITERAL: true +# @example ValueCapitalization: nil (default) +# # any capitalization is accepted +# +# # good +# # frozen-string-literal: true +# +# # good +# # frozen-string-literal: TRUE +# @example ValueCapitalization: lowercase +# # when a value is not given, any capitalization is accepted +# +# # bad +# # frozen-string-literal: TRUE +# +# # good +# # frozen-string-literal: TRUE +# @example EnforcedStyle: snake_case (default) +# # The `snake_case` style will enforce that the frozen string literal +# # comment is written in snake case. (Words separated by underscores) +# # bad +# # frozen-string-literal: true +# +# module Bar +# # ... +# end +# +# # good +# # frozen_string_literal: false +# +# module Bar +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:97 +class RuboCop::Cop::Style::MagicCommentFormat < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:156 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:241 + def correct_separator; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:279 + def directive_capitalization; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:197 + def directive_offends?(directive); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:233 + def expected_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:183 + def find_issues(comment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:207 + def fix_directives(issues); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:221 + def fix_values(issues); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:245 + def incorrect_separator?(text); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:173 + def leading_comment_lines; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:275 + def line_range(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:167 + def magic_comments; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:202 + def register_offenses(issues); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:264 + def replace_capitalization(text, style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:260 + def replace_separator(text); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:301 + def supported_capitalizations; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:295 + def valid_capitalization?(style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:287 + def value_capitalization; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:249 + def wrong_capitalization?(text, expected_case); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:237 + def wrong_separator; end +end + +# Value object to extract source ranges for the different parts of a magic comment +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:107 +class RuboCop::Cop::Style::MagicCommentFormat::CommentRange + extend ::Forwardable + + # @return [CommentRange] a new instance of CommentRange + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:119 + def initialize(comment); end + + # Returns the value of attribute comment. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:117 + def comment; end + + # A magic comment can contain one directive (normal style) or + # multiple directives (emacs style) + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:125 + def directives; end + + # source://RUBY_ROOT/forwardable.rb:226 + def loc(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def text(*args, &block); end + + # A magic comment can contain one value (normal style) or + # multiple directives (emacs style) + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:141 + def values; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:110 +RuboCop::Cop::Style::MagicCommentFormat::CommentRange::DIRECTIVE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:114 +RuboCop::Cop::Style::MagicCommentFormat::CommentRange::VALUE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:102 +RuboCop::Cop::Style::MagicCommentFormat::KEBAB_SEPARATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:103 +RuboCop::Cop::Style::MagicCommentFormat::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:104 +RuboCop::Cop::Style::MagicCommentFormat::MSG_VALUE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/magic_comment_format.rb:101 +RuboCop::Cop::Style::MagicCommentFormat::SNAKE_SEPARATOR = T.let(T.unsafe(nil), String) + +# Prefer `select` or `reject` over `map { ... }.compact`. +# +# @example +# +# # bad +# array.map { |e| some_condition? ? e : next }.compact +# +# # bad +# array.map do |e| +# if some_condition? +# e +# else +# next +# end +# end.compact +# +# # bad +# array.map do |e| +# next if some_condition? +# +# e +# end.compact +# +# # bad +# array.map do |e| +# e if some_condition? +# end.compact +# +# # good +# array.select { |e| some_condition? } +# +# # good +# array.reject { |e| some_condition? } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:40 +class RuboCop::Cop::Style::MapCompactWithConditionalBlock < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:46 + def map_and_compact?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:72 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:125 + def range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:91 + def returns_block_argument?(block_argument_node, return_value_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:95 + def truthy_branch?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:115 + def truthy_branch_for_guard?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:105 + def truthy_branch_for_if?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/map_compact_with_conditional_block.rb:43 +RuboCop::Cop::Style::MapCompactWithConditionalBlock::MSG = T.let(T.unsafe(nil), String) + +# Looks for uses of `map.to_h` or `collect.to_h` that could be +# written with just `to_h` in Ruby >= 2.6. +# +# NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will +# also change this pattern if only hash keys or hash values are being +# transformed. +# +# @example +# # bad +# something.map { |v| [v, v * 2] }.to_h +# +# # good +# something.to_h { |v| [v, v * 2] } +# +# # bad +# {foo: bar}.collect { |k, v| [k.to_s, v.do_something] }.to_h +# +# # good +# {foo: bar}.to_h { |k, v| [k.to_s, v.do_something] } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:30 +class RuboCop::Cop::Style::MapToHash < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:41 + def map_to_h?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:45 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:59 + def autocorrect(corrector, to_h, map); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:37 +RuboCop::Cop::Style::MapToHash::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/map_to_hash.rb:38 +RuboCop::Cop::Style::MapToHash::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the presence (default) or absence of parentheses in +# method calls containing parameters. +# +# In the default style (require_parentheses), macro methods are allowed. +# Additional methods can be added to the `AllowedMethods` +# or `AllowedPatterns` list. These options are +# valid only in the default style. Macros can be included by +# either setting `IgnoreMacros` to false or adding specific macros to +# the `IncludedMacros` list. +# +# Precedence of options is all follows: +# +# 1. `AllowedMethods` +# 2. `AllowedPatterns` +# 3. `IncludedMacros` +# +# eg. If a method is listed in both +# `IncludedMacros` and `AllowedMethods`, then the latter takes +# precedence (that is, the method is allowed). +# +# In the alternative style (omit_parentheses), there are three additional +# options. +# +# 1. `AllowParenthesesInChaining` is `false` by default. Setting it to +# `true` allows the presence of parentheses in the last call during +# method chaining. +# +# 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it +# to `true` allows the presence of parentheses in multi-line method +# calls. +# +# 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This +# allows the presence of parentheses when calling a method whose name +# begins with a capital letter and which has no arguments. Setting it +# to `true` allows the presence of parentheses in such a method call +# even with arguments. +# +# NOTE: Parentheses are still allowed in cases where omitting them +# results in ambiguous or syntactically incorrect code. For example, +# parentheses are required around a method with arguments when inside an +# endless method definition introduced in Ruby 3.0. Parentheses are also +# allowed when forwarding arguments with the triple-dot syntax introduced +# in Ruby 2.7 as omitting them starts an endless range. +# And Ruby 3.1's hash omission syntax has a case that requires parentheses +# because of the following issue: https://bugs.ruby-lang.org/issues/18396. +# +# @example AllowParenthesesInStringInterpolation: true +# +# # good +# "#{t('this.is.good')}" +# +# # good +# "#{t 'this.is.also.good'}" +# @example EnforcedStyle: omit_parentheses +# +# # bad +# array.delete(e) +# +# # good +# array.delete e +# +# # bad +# foo.enforce(strict: true) +# +# # good +# foo.enforce strict: true +# +# # good +# # Allows parens for calls that won't produce valid Ruby or be ambiguous. +# model.validate strict(true) +# +# # good +# # Allows parens for calls that won't produce valid Ruby or be ambiguous. +# yield path, File.basename(path) +# +# # good +# # Operators methods calls with parens +# array&.[](index) +# +# # good +# # Operators methods without parens, if you prefer +# array.[] index +# +# # good +# # Operators methods calls with parens +# array&.[](index) +# +# # good +# # Operators methods without parens, if you prefer +# array.[] index +# @example IgnoreMacros: true (default) +# +# # good +# class Foo +# bar :baz +# end +# @example IgnoreMacros: false +# +# # bad +# class Foo +# bar :baz +# end +# @example AllowParenthesesInMultilineCall: false (default) +# +# # bad +# foo.enforce( +# strict: true +# ) +# +# # good +# foo.enforce \ +# strict: true +# @example AllowParenthesesInMultilineCall: true +# +# # good +# foo.enforce( +# strict: true +# ) +# +# # good +# foo.enforce \ +# strict: true +# @example AllowParenthesesInChaining: false (default) +# +# # bad +# foo().bar(1) +# +# # good +# foo().bar 1 +# @example AllowParenthesesInChaining: true +# +# # good +# foo().bar(1) +# +# # good +# foo().bar 1 +# @example AllowParenthesesInCamelCaseMethod: false (default) +# +# # bad +# Array(1) +# +# # good +# Array 1 +# @example AllowParenthesesInCamelCaseMethod: true +# +# # good +# Array(1) +# +# # good +# Array 1 +# @example AllowParenthesesInStringInterpolation: false (default) +# +# # bad +# "#{t('this.is.bad')}" +# +# # good +# "#{t 'this.is.better'}" +# @example EnforcedStyle: require_parentheses (default) +# +# # bad +# array.delete e +# +# # good +# array.delete(e) +# +# # good +# # Operators don't need parens +# foo == bar +# +# # good +# # Setter methods don't need parens +# foo.bar = baz +# +# # okay with `puts` listed in `AllowedMethods` +# puts 'test' +# +# # okay with `^assert` listed in `AllowedPatterns` +# assert_equal 'test', x +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:195 +class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:210 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:210 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:210 + def on_super(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:210 + def on_yield(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:219 + def args_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:228 + def args_end(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:232 + def args_parenthesized?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses.rb:206 + def autocorrect_incompatible_with; end + end +end + +# Style omit_parentheses +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:9 +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:76 + def allowed_camel_case_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:160 + def allowed_chained_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:156 + def allowed_multiline_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:81 + def allowed_string_interpolation_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:169 + def ambiguous_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:198 + def assigned_before?(node, target); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:33 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:143 + def call_as_argument_or_chain?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:103 + def call_in_literals?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:112 + def call_in_logical_operators?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:120 + def call_in_optional_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:124 + def call_in_single_line_inheritance?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:128 + def call_with_ambiguous_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:138 + def call_with_braced_block?(node); end + + # Require hash value omission be enclosed in parentheses to prevent the following issue: + # https://bugs.ruby-lang.org/issues/18396. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:64 + def exist_next_line_expression?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:185 + def hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:149 + def hash_literal_in_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:46 + def inside_endless_method_def?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:202 + def inside_string_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:93 + def legitimate_call_with_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:181 + def logical_operator?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:58 + def modifier_form?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:42 + def offense_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:17 + def omit_parentheses(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:86 + def parentheses_at_the_end_of_multiline_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:189 + def regexp_slash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:51 + def require_parentheses_for_hash_value_omission?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:173 + def splat?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:72 + def super_call_without_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:68 + def syntax_like_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:177 + def ternary_if?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:193 + def unary_literal?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:11 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::OMIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:10 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp) + +# Style require_parentheses +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:8 +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:27 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:31 + def eligible_for_parentheses_omission?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:39 + def ignored_macro?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:35 + def included_macros_list; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:14 + def require_parentheses(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb:9 +RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses::REQUIRE_MSG = T.let(T.unsafe(nil), String) + +# Checks for unwanted parentheses in parameterless method calls. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# @example +# # bad +# object.some_method() +# +# # good +# object.some_method +# @example AllowedMethods: [] (default) +# # bad +# object.foo() +# @example AllowedMethods: [foo] +# # good +# object.foo() +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:26 +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:33 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:60 + def allowed_method_name?(name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:72 + def any_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:56 + def default_argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:52 + def ineligible_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:95 + def offense_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:45 + def register_offense(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:64 + def same_name_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:88 + def variable_in_mass_assignment?(variable_name, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_call_without_args_parentheses.rb:31 +RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String) + +# Checks for methods called on a do...end block. The point of +# this check is that it's easy to miss the call tacked on to the block +# when reading code. +# +# @example +# # bad +# a do +# b +# end.c +# +# # good +# a { b }.c +# +# # good +# foo = a do +# b +# end +# foo.c +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:24 +class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:29 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:40 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:29 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:40 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_called_on_do_end_block.rb:27 +RuboCop::Cop::Style::MethodCalledOnDoEndBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for parentheses around the arguments in method +# definitions. Both instance and class/singleton methods are checked. +# +# Regardless of style, parentheses are necessary for: +# +# 1. Endless methods +# 2. Argument lists containing a `forward-arg` (`...`) +# 3. Argument lists containing an anonymous block forwarding (`&`) +# +# Removing the parens would be a syntax error here. +# +# @example EnforcedStyle: require_parentheses (default) +# # The `require_parentheses` style requires method definitions +# # to always use parentheses +# +# # bad +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# +# # good +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# @example EnforcedStyle: require_no_parentheses +# # The `require_no_parentheses` style requires method definitions +# # to never use parentheses +# +# # bad +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# +# # good +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# @example EnforcedStyle: require_no_parentheses_except_multiline +# # The `require_no_parentheses_except_multiline` style prefers no +# # parentheses when method definition arguments fit on single line, +# # but prefers parentheses when arguments span multiple lines. +# +# # bad +# def bar(num1, num2) +# num1 + num2 +# end +# +# def foo descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name +# do_something +# end +# +# # good +# def bar num1, num2 +# num1 + num2 +# end +# +# def foo(descriptive_var_name, +# another_descriptive_var_name, +# last_descriptive_var_name) +# do_something +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:95 +class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:103 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:103 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:165 + def anonymous_block_arg?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:143 + def arguments_without_parentheses?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:124 + def correct_arguments(arg_node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:129 + def forced_parentheses?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:147 + def missing_parentheses(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:138 + def require_parentheses?(args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:157 + def unwanted_parentheses(args); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:101 +RuboCop::Cop::Style::MethodDefParentheses::MSG_MISSING = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/method_def_parentheses.rb:100 +RuboCop::Cop::Style::MethodDefParentheses::MSG_PRESENT = T.let(T.unsafe(nil), String) + +# Checks for potential uses of `Enumerable#minmax`. +# +# @example +# +# # bad +# bar = [foo.min, foo.max] +# return foo.min, foo.max +# +# # good +# bar = foo.minmax +# return foo.minmax +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:17 +class RuboCop::Cop::Style::MinMax < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:38 + def min_max_candidate(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:22 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:22 + def on_return(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:55 + def argument_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:42 + def message(offender, receiver); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:46 + def offending_range(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/min_max.rb:20 +RuboCop::Cop::Style::MinMax::MSG = T.let(T.unsafe(nil), String) + +# Checks for `if` expressions that do not have an `else` branch. +# +# NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`, +# it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`. +# +# Supported styles are: if, case, both. +# +# @example EnforcedStyle: both (default) +# # warn when an `if` or `case` expression is missing an `else` branch. +# +# # bad +# if condition +# statement +# end +# +# # bad +# case var +# when condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# @example EnforcedStyle: if +# # warn when an `if` expression is missing an `else` branch. +# +# # bad +# if condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# case var +# when condition +# statement +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# @example EnforcedStyle: case +# # warn when a `case` expression is missing an `else` branch. +# +# # bad +# case var +# when condition +# statement +# end +# +# # good +# case var +# when condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# # good +# if condition +# statement +# end +# +# # good +# if condition +# statement +# else +# # the content of `else` branch will be determined by Style/EmptyElse +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:99 +class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:114 + def on_case(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:120 + def on_case_match(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:107 + def on_normal_if_unless(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:147 + def case_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:126 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:169 + def empty_else_config; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:159 + def empty_else_cop_enabled?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:163 + def empty_else_style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:143 + def if_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:132 + def message_template; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:155 + def unless_else_config; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:151 + def unless_else_cop_enabled?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:103 +RuboCop::Cop::Style::MissingElse::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:105 +RuboCop::Cop::Style::MissingElse::MSG_EMPTY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_else.rb:104 +RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String) + +# Checks for the presence of `method_missing` without also +# defining `respond_to_missing?`. +# +# @example +# #bad +# def method_missing(name, *args) +# # ... +# end +# +# #good +# def respond_to_missing?(name, include_private) +# # ... +# end +# +# def method_missing(name, *args) +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_respond_to_missing.rb:24 +class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_respond_to_missing.rb:27 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_respond_to_missing.rb:27 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/missing_respond_to_missing.rb:37 + def implements_respond_to_missing?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/missing_respond_to_missing.rb:25 +RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String) + +# Checks for grouping of mixins in `class` and `module` bodies. +# By default it enforces mixins to be placed in separate declarations, +# but it can be configured to enforce grouping them in one declaration. +# +# @example EnforcedStyle: separated (default) +# # bad +# class Foo +# include Bar, Qox +# end +# +# # good +# class Foo +# include Qox +# include Bar +# end +# @example EnforcedStyle: grouped +# # bad +# class Foo +# extend Bar +# extend Qox +# end +# +# # good +# class Foo +# extend Qox, Bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:33 +class RuboCop::Cop::Style::MixinGrouping < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:40 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:40 + def on_module(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:64 + def check(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:72 + def check_grouped_style(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:91 + def check_separated_style(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:127 + def group_mixins(node, mixins); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:110 + def grouped_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:53 + def range_to_remove_for_subsequent_mixin(mixins, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:118 + def separate_mixins(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:114 + def separated_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:104 + def sibling_mixins(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:37 +RuboCop::Cop::Style::MixinGrouping::MIXIN_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_grouping.rb:38 +RuboCop::Cop::Style::MixinGrouping::MSG = T.let(T.unsafe(nil), String) + +# Checks that `include`, `extend` and `prepend` statements appear +# inside classes and modules, not at the top level, so as to not affect +# the behavior of `Object`. +# +# @example +# # bad +# include M +# +# class C +# end +# +# # bad +# extend M +# +# class C +# end +# +# # bad +# prepend M +# +# class C +# end +# +# # good +# class C +# include M +# end +# +# # good +# class C +# extend M +# end +# +# # good +# class C +# prepend M +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:43 +class RuboCop::Cop::Style::MixinUsage < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:54 + def in_top_level_scope?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:48 + def include_statement(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:62 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:44 +RuboCop::Cop::Style::MixinUsage::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/mixin_usage.rb:45 +RuboCop::Cop::Style::MixinUsage::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for use of `extend self` or `module_function` in a +# module. +# +# Supported styles are: module_function, extend_self, forbidden. `forbidden` +# style prohibits the usage of both styles. +# +# NOTE: the cop won't be activated when the module contains any private methods. +# +# @example EnforcedStyle: module_function (default) +# # bad +# module Test +# extend self +# # ... +# end +# +# # good +# module Test +# module_function +# # ... +# end +# @example EnforcedStyle: module_function (default) +# # good +# module Test +# extend self +# # ... +# private +# # ... +# end +# @example EnforcedStyle: extend_self +# # bad +# module Test +# module_function +# # ... +# end +# +# # good +# module Test +# extend self +# # ... +# end +# @example EnforcedStyle: forbidden +# # bad +# module Test +# module_function +# # ... +# end +# +# # bad +# module Test +# extend self +# # ... +# end +# +# # bad +# module Test +# extend self +# # ... +# private +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:73 +class RuboCop::Cop::Style::ModuleFunction < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:85 + def extend_self_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:82 + def module_function_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:90 + def on_module(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:88 + def private_directive?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:127 + def check_extend_self(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:133 + def check_forbidden(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:119 + def check_module_function(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:108 + def each_wrong_style(nodes, &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:140 + def message(_range); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:78 +RuboCop::Cop::Style::ModuleFunction::EXTEND_SELF_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:79 +RuboCop::Cop::Style::ModuleFunction::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/module_function.rb:77 +RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), String) + +# Checks for chaining of a block after another block that spans +# multiple lines. +# +# @example +# +# # bad +# Thread.list.select do |t| +# t.alive? +# end.map do |t| +# t.object_id +# end +# +# # good +# alive_threads = Thread.list.select do |t| +# t.alive? +# end +# alive_threads.map do |t| +# t.object_id +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_block_chain.rb:25 +class RuboCop::Cop::Style::MultilineBlockChain < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_block_chain.rb:30 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_block_chain.rb:30 + def on_numblock(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_block_chain.rb:28 +RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of if/unless modifiers with multiple-lines bodies. +# +# @example +# +# # bad +# { +# result: 'this should not happen' +# } unless cond +# +# # good +# { result: 'ok' } if cond +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:17 +class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:25 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:43 + def configured_indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:47 + def indented_body(body, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:35 + def to_normal_if(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_modifier.rb:22 +RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of the `then` keyword in multi-line if statements. +# +# @example +# # bad +# # This is considered bad practice. +# if cond then +# end +# +# # good +# # If statements can contain `then` on the same line. +# if cond then a +# elsif cond then b +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_then.rb:19 +class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_then.rb:28 + def on_normal_if_unless(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_then.rb:38 + def non_modifier_then?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_then.rb:26 +RuboCop::Cop::Style::MultilineIfThen::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_if_then.rb:24 +RuboCop::Cop::Style::MultilineIfThen::NON_MODIFIER_THEN = T.let(T.unsafe(nil), Regexp) + +# Checks uses of the `then` keyword in multi-line `in` statement. +# +# @example +# # bad +# case expression +# in pattern then +# end +# +# # good +# case expression +# in pattern +# end +# +# # good +# case expression +# in pattern then do_something +# end +# +# # good +# case expression +# in pattern then do_something(arg1, +# arg2) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_in_pattern_then.rb:30 +class RuboCop::Cop::Style::MultilineInPatternThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_in_pattern_then.rb:39 + def on_in_pattern(node); end + + private + + # Requires `then` for write `in` and its body on the same line. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_in_pattern_then.rb:51 + def require_then?(in_pattern_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_in_pattern_then.rb:37 +RuboCop::Cop::Style::MultilineInPatternThen::MSG = T.let(T.unsafe(nil), String) + +# Checks expressions wrapping styles for multiline memoization. +# +# @example EnforcedStyle: keyword (default) +# # bad +# foo ||= ( +# bar +# baz +# ) +# +# # good +# foo ||= begin +# bar +# baz +# end +# @example EnforcedStyle: braces +# # bad +# foo ||= begin +# bar +# baz +# end +# +# # good +# foo ||= ( +# bar +# baz +# ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:33 +class RuboCop::Cop::Style::MultilineMemoization < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:55 + def message(_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:40 + def on_or_asgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:61 + def bad_rhs?(rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:71 + def keyword_autocorrect(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:77 + def keyword_begin_str(node, node_buf); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:86 + def keyword_end_str(node, node_buf); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:38 +RuboCop::Cop::Style::MultilineMemoization::BRACES_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_memoization.rb:37 +RuboCop::Cop::Style::MultilineMemoization::KEYWORD_MSG = T.let(T.unsafe(nil), String) + +# Checks for method signatures that span multiple lines. +# +# @example +# +# # good +# +# def foo(bar, baz) +# end +# +# # bad +# +# def foo(bar, +# baz) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:21 +class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:27 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:27 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:57 + def arguments_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:38 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:69 + def closing_line(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:73 + def correction_exceeds_max_line_length?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:81 + def definition_width(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:77 + def indentation_width(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:53 + def last_line_source_of_arguments(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:85 + def max_line_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:65 + def opening_line(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_method_signature.rb:25 +RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String) + +# Checks for multi-line ternary op expressions. +# +# NOTE: `return if ... else ... end` is syntax error. If `return` is used before +# multiline ternary operator expression, it will be autocorrected to single-line +# ternary operator. The same is true for `break`, `next`, and method call. +# +# @example +# # bad +# a = cond ? +# b : c +# a = cond ? b : +# c +# a = cond ? +# b : +# c +# +# return cond ? +# b : +# c +# +# # good +# a = cond ? b : c +# a = if cond +# b +# else +# c +# end +# +# return cond ? b : c +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:36 +class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:43 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:75 + def enforce_single_line_ternary_operator?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:57 + def offense?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:61 + def replacement(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:79 + def use_assignment_method?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:39 +RuboCop::Cop::Style::MultilineTernaryOperator::MSG_IF = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:40 +RuboCop::Cop::Style::MultilineTernaryOperator::MSG_SINGLE_LINE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_ternary_operator.rb:41 +RuboCop::Cop::Style::MultilineTernaryOperator::SINGLE_LINE_TYPES = T.let(T.unsafe(nil), Array) + +# Checks uses of the `then` keyword +# in multi-line when statements. +# +# @example +# # bad +# case foo +# when bar then +# end +# +# # good +# case foo +# when bar +# end +# +# # good +# case foo +# when bar then do_something +# end +# +# # good +# case foo +# when bar then do_something(arg1, +# arg2) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_when_then.rb:31 +class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_when_then.rb:37 + def on_when(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_when_then.rb:58 + def accept_node_type?(node); end + + # Requires `then` for write `when` and its body on the same line. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_when_then.rb:49 + def require_then?(when_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiline_when_then.rb:35 +RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String) + +# Checks against comparing a variable with multiple items, where +# `Array#include?`, `Set#include?` or a `case` could be used instead +# to avoid code repetition. +# It accepts comparisons of multiple method calls to avoid unnecessary method calls +# by default. It can be configured by `AllowMethodComparison` option. +# +# @example +# # bad +# a = 'a' +# foo if a == 'a' || a == 'b' || a == 'c' +# +# # good +# a = 'a' +# foo if ['a', 'b', 'c'].include?(a) +# +# VALUES = Set['a', 'b', 'c'].freeze +# # elsewhere... +# foo if VALUES.include?(a) +# +# case foo +# when 'a', 'b', 'c' then foo +# # ... +# end +# +# # accepted (but consider `case` as above) +# foo if a == b.lightweight || a == b.heavyweight +# @example AllowMethodComparison: true (default) +# # good +# foo if a == b.lightweight || a == b.heavyweight +# @example AllowMethodComparison: false +# # bad +# foo if a == b.lightweight || a == b.heavyweight +# +# # good +# foo if [b.lightweight, b.heavyweight].include?(a) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:43 +class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:49 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:53 + def on_or(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:78 + def simple_comparison_lhs?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:83 + def simple_comparison_rhs?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:75 + def simple_double_comparison?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:151 + def allow_method_comparison?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:126 + def comparison?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:118 + def nested_comparison?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:87 + def nested_variable_comparison?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:146 + def reset_comparison; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:130 + def root_of_or_node(or_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:140 + def switch_comparison?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:114 + def variable_name(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:93 + def variables_in_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:101 + def variables_in_simple_node(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/multiple_comparison.rb:46 +RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) + +# Checks whether some constant value isn't a +# mutable literal (e.g. array or hash). +# +# Strict mode can be used to freeze all constants, rather than +# just literals. +# Strict mode is considered an experimental feature. It has not been +# updated with an exhaustive list of all methods that will produce +# frozen objects so there is a decent chance of getting some false +# positives. Luckily, there is no harm in freezing an already +# frozen object. +# +# From Ruby 3.0, this cop honours the magic comment +# 'shareable_constant_value'. When this magic comment is set to any +# acceptable value other than none, it will suppress the offenses +# raised by this cop. It enforces frozen state. +# +# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0. +# +# NOTE: From Ruby 3.0, interpolated strings are not frozen when +# `# frozen-string-literal: true` is used, so this cop enforces explicit +# freezing for such strings. +# +# NOTE: From Ruby 3.0, this cop allows explicit freezing of constants when +# the `shareable_constant_value` directive is used. +# +# @example EnforcedStyle: literals (default) +# # bad +# CONST = [1, 2, 3] +# +# # good +# CONST = [1, 2, 3].freeze +# +# # good +# CONST = <<~TESTING.freeze +# This is a heredoc +# TESTING +# +# # good +# CONST = Something.new +# @example EnforcedStyle: strict +# # bad +# CONST = Something.new +# +# # bad +# CONST = Struct.new do +# def foo +# puts 1 +# end +# end +# +# # good +# CONST = Something.new.freeze +# +# # good +# CONST = Struct.new do +# def foo +# puts 1 +# end +# end.freeze +# @example +# # Magic comment - shareable_constant_value: literal +# +# # bad +# CONST = [1, 2, 3] +# +# # good +# # shareable_constant_value: literal +# CONST = [1, 2, 3] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:87 +class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb:15 + def on_assignment(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:127 + def on_casgn(node); end + + # Some of these patterns may not actually return an immutable object, + # but we want to consider them immutable for this cop. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:224 + def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:241 + def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:217 + def splat_value(param0 = T.unsafe(nil)); end + + # source://rubocop-sorbet-0.6.11/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb:10 + def t_let(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:169 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:158 + def check(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:208 + def correct_splat_expansion(corrector, expr, splat_value); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:200 + def frozen_regexp_or_range_literals?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:190 + def immutable_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:184 + def mutable_literal?(value); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:204 + def requires_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:194 + def shareable_constant_value?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:149 + def strict_check(value); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:125 +RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String) + +# Handles magic comment shareable_constant_value with O(n ^ 2) complexity +# n - number of lines in the source +# Iterates over all lines before a CONSTANT +# until it reaches shareable_constant_value +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:88 +module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue + private + + # Identifies the most recent magic comment with valid shareable constant values + # that's in scope for this node + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:102 + def magic_comment_in_scope(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:110 + def processed_source_till_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:91 + def recent_shareable_value?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:114 + def shareable_constant_value_enabled?(value); end + + class << self + # Identifies the most recent magic comment with valid shareable constant values + # that's in scope for this node + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:102 + def magic_comment_in_scope(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/mutable_constant.rb:91 + def recent_shareable_value?(node); end + end +end + +# Checks for uses of if with a negated condition. Only ifs +# without else are considered. There are three different styles: +# +# * both +# * prefix +# * postfix +# +# @example EnforcedStyle: both (default) +# # enforces `unless` for `prefix` and `postfix` conditionals +# +# # bad +# +# if !foo +# bar +# end +# +# # good +# +# unless foo +# bar +# end +# +# # bad +# +# bar if !foo +# +# # good +# +# bar unless foo +# @example EnforcedStyle: prefix +# # enforces `unless` for just `prefix` conditionals +# +# # bad +# +# if !foo +# bar +# end +# +# # good +# +# unless foo +# bar +# end +# +# # good +# +# bar if !foo +# @example EnforcedStyle: postfix +# # enforces `unless` for just `postfix` conditionals +# +# # bad +# +# bar if !foo +# +# # good +# +# bar unless foo +# +# # good +# +# if !foo +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if.rb:71 +class RuboCop::Cop::Style::NegatedIf < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if.rb:76 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if.rb:92 + def correct_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if.rb:88 + def message(node); end +end + +# Checks for uses of `if-else` and ternary operators with a negated condition +# which can be simplified by inverting condition and swapping branches. +# +# @example +# # bad +# if !x +# do_something +# else +# do_something_else +# end +# +# # good +# if x +# do_something_else +# else +# do_something +# end +# +# # bad +# !x ? do_something : do_something_else +# +# # good +# x ? do_something_else : do_something +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:30 +class RuboCop::Cop::Style::NegatedIfElseCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:39 + def double_negation?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:49 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:45 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:83 + def correct_negated_condition(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:79 + def corrected_ancestor?(node); end + + # Collect the entire else branch, including whitespace and comments + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:118 + def else_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:69 + def if_else?(node); end + + # Collect the entire if branch, including whitespace and comments + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:109 + def if_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:74 + def negated_condition?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:96 + def swap_branches(corrector, node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:41 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:34 +RuboCop::Cop::Style::NegatedIfElseCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_if_else_condition.rb:36 +RuboCop::Cop::Style::NegatedIfElseCondition::NEGATED_EQUALITY_METHODS = T.let(T.unsafe(nil), Array) + +# Checks for uses of unless with a negated condition. Only unless +# without else are considered. There are three different styles: +# +# * both +# * prefix +# * postfix +# +# @example EnforcedStyle: both (default) +# # enforces `if` for `prefix` and `postfix` conditionals +# +# # bad +# unless !foo +# bar +# end +# +# # good +# if foo +# bar +# end +# +# # bad +# bar unless !foo +# +# # good +# bar if foo +# @example EnforcedStyle: prefix +# # enforces `if` for just `prefix` conditionals +# +# # bad +# unless !foo +# bar +# end +# +# # good +# if foo +# bar +# end +# +# # good +# bar unless !foo +# @example EnforcedStyle: postfix +# # enforces `if` for just `postfix` conditionals +# +# # bad +# bar unless !foo +# +# # good +# bar if foo +# +# # good +# unless !foo +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_unless.rb:61 +class RuboCop::Cop::Style::NegatedUnless < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_unless.rb:66 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_unless.rb:82 + def correct_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_unless.rb:78 + def message(node); end +end + +# Checks for uses of while with a negated condition. +# +# @example +# # bad +# while !foo +# bar +# end +# +# # good +# until foo +# bar +# end +# +# # bad +# bar until !foo +# +# # good +# bar while foo +# bar while !foo && baz +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/negated_while.rb:25 +class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Base + include ::RuboCop::Cop::NegativeConditional + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_while.rb:29 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/negated_while.rb:29 + def on_while(node); end +end + +# Checks for nested `File.dirname`. +# It replaces nested `File.dirname` with the level argument introduced in Ruby 3.1. +# +# @example +# +# # bad +# File.dirname(File.dirname(path)) +# +# # good +# File.dirname(path, 2) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:17 +class RuboCop::Cop::Style::NestedFileDirname < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:28 + def file_dirname?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:33 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:60 + def offense_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:49 + def path_with_dir_level(node, level); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:22 +RuboCop::Cop::Style::NestedFileDirname::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_file_dirname.rb:23 +RuboCop::Cop::Style::NestedFileDirname::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for nested use of if, unless, while and until in their +# modifier form. +# +# @example +# +# # bad +# something if a if b +# +# # good +# something if b && a +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:16 +class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:22 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:22 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:22 + def on_while(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:85 + def add_parentheses_to_method_arguments(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:42 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:30 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:65 + def left_hand_operand(node, operator); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:38 + def modifier?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:51 + def new_expression(inner_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:61 + def replacement_operator(keyword); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:94 + def requires_parens?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:71 + def right_hand_operand(node, left_hand_keyword); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_modifier.rb:20 +RuboCop::Cop::Style::NestedModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for unparenthesized method calls in the argument list +# of a parenthesized method call. +# `be`, `be_a`, `be_an`, `be_between`, `be_falsey`, `be_kind_of`, `be_instance_of`, +# `be_truthy`, `be_within`, `eq`, `eql`, `end_with`, `include`, `match`, `raise_error`, +# `respond_to`, and `start_with` methods are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # good +# method1(method2(arg)) +# +# # bad +# method1(method2 arg) +# @example AllowedMethods: [foo] +# # good +# method1(foo arg) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:24 +class RuboCop::Cop::Style::NestedParenthesizedCalls < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:35 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:35 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:71 + def allowed?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:65 + def allowed_omission?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:51 + def autocorrect(corrector, nested); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:31 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_parenthesized_calls.rb:29 +RuboCop::Cop::Style::NestedParenthesizedCalls::MSG = T.let(T.unsafe(nil), String) + +# Checks for nested ternary op expressions. +# +# @example +# # bad +# a ? (b ? b1 : b2) : a2 +# +# # good +# if a +# b ? b1 : b2 +# else +# a2 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:18 +class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:25 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:48 + def autocorrect(corrector, if_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:41 + def if_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:55 + def remove_parentheses(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:61 + def replace_loc_and_whitespace(corrector, range, replacement); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nested_ternary_operator.rb:23 +RuboCop::Cop::Style::NestedTernaryOperator::MSG = T.let(T.unsafe(nil), String) + +# Use `next` to skip iteration instead of a condition at the end. +# +# @example EnforcedStyle: skip_modifier_ifs (default) +# # bad +# [1, 2].each do |a| +# if a == 1 +# puts a +# end +# end +# +# # good +# [1, 2].each do |a| +# next unless a == 1 +# puts a +# end +# +# # good +# [1, 2].each do |a| +# puts a if a == 1 +# end +# @example EnforcedStyle: always +# # With `always` all conditions at the end of an iteration needs to be +# # replaced by next - with `skip_modifier_ifs` the modifier if like +# # this one are ignored: `[1, 2].each { |a| puts a if a == 1 }` +# +# # bad +# [1, 2].each do |a| +# puts a if a == 1 +# end +# +# # bad +# [1, 2].each do |a| +# if a == 1 +# puts a +# end +# end +# +# # good +# [1, 2].each do |a| +# next unless a == 1 +# puts a +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:49 +class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:68 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:76 + def on_for(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:62 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:68 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:76 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:76 + def on_while(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:213 + def actual_indent(lines, buffer); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:112 + def allowed_modifier_if?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:155 + def autocorrect_block(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:145 + def autocorrect_modifier(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:84 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:170 + def cond_range(node, cond); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:189 + def end_followed_by_whitespace_only?(source_buffer, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:180 + def end_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:98 + def ends_with_condition?(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:128 + def exit_body_type?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:217 + def heredoc_lines(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:120 + def if_else_children?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:124 + def if_without_else?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:140 + def offense_location(offense_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:134 + def offense_node(body); end + + # Adjust indentation of `lines` to match `node` + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:204 + def reindent(lines, node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:224 + def reindent_line(corrector, lineno, delta, buffer); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:193 + def reindentable_lines(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:104 + def simple_if_without_break?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:58 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:56 +RuboCop::Cop::Style::Next::EXIT_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/next.rb:55 +RuboCop::Cop::Style::Next::MSG = T.let(T.unsafe(nil), String) + +# Checks for comparison of something with nil using `==` and +# `nil?`. +# +# Supported styles are: predicate, comparison. +# +# @example EnforcedStyle: predicate (default) +# +# # bad +# if x == nil +# end +# +# # good +# if x.nil? +# end +# @example EnforcedStyle: comparison +# +# # bad +# if x.nil? +# end +# +# # good +# if x == nil +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:31 +class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:44 + def nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:41 + def nil_comparison?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:46 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:65 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:77 + def prefer_comparison?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:69 + def style_check?(node, &block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:36 +RuboCop::Cop::Style::NilComparison::EXPLICIT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:35 +RuboCop::Cop::Style::NilComparison::PREDICATE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_comparison.rb:38 +RuboCop::Cop::Style::NilComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for lambdas and procs that always return nil, +# which can be replaced with an empty lambda or proc instead. +# +# @example +# # bad +# -> { nil } +# +# lambda do +# next nil +# end +# +# proc { nil } +# +# Proc.new do +# break nil +# end +# +# # good +# -> {} +# +# lambda do +# end +# +# -> (x) { nil if x } +# +# proc {} +# +# Proc.new { nil if x } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_lambda.rb:35 +class RuboCop::Cop::Style::NilLambda < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_lambda.rb:42 + def nil_return?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_lambda.rb:46 + def on_block(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/nil_lambda.rb:58 + def autocorrect(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/nil_lambda.rb:39 +RuboCop::Cop::Style::NilLambda::MSG = T.let(T.unsafe(nil), String) + +# Checks for non-nil checks, which are usually redundant. +# +# With `IncludeSemanticChanges` set to `false` by default, this cop +# does not report offenses for `!x.nil?` and does no changes that might +# change behavior. +# Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of +# `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and +# does no changes to `!x.nil?` style. +# +# With `IncludeSemanticChanges` set to `true`, this cop reports offenses +# for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which +# is *usually* OK, but might change behavior. +# +# @example +# # bad +# if x != nil +# end +# +# # good +# if x +# end +# +# # Non-nil checks are allowed if they are the final nodes of predicate. +# # good +# def signed_in? +# !current_user.nil? +# end +# @example IncludeSemanticChanges: false (default) +# # good +# if !x.nil? +# end +# @example IncludeSemanticChanges: true +# # bad +# if !x.nil? +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:44 +class RuboCop::Cop::Style::NonNilCheck < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:59 + def nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:62 + def not_and_nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:53 + def not_equal_to_nil?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:73 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:73 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:64 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:56 + def unless_check?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:93 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:123 + def autocorrect_comparison(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:137 + def autocorrect_non_nil(corrector, node, inner_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:145 + def autocorrect_unless_nil(corrector, node, receiver); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:119 + def include_semantic_changes?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:110 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:150 + def nil_comparison_style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:88 + def register_offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:104 + def unless_and_nil_check?(send_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:48 +RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REDUNDANCY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:47 +RuboCop::Cop::Style::NonNilCheck::MSG_FOR_REPLACEMENT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/non_nil_check.rb:50 +RuboCop::Cop::Style::NonNilCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of the keyword `not` instead of `!`. +# +# @example +# +# # bad - parentheses are required because of op precedence +# x = (not something) +# +# # good +# x = !something +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:16 +class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:32 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:60 + def correct_opposite_method(corrector, range, child); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:65 + def correct_with_parens(corrector, range, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:70 + def correct_without_parens(corrector, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:50 + def opposite_method?(child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:54 + def requires_parens?(child); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:20 +RuboCop::Cop::Style::Not::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:23 +RuboCop::Cop::Style::Not::OPPOSITE_METHODS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/not.rb:21 +RuboCop::Cop::Style::Not::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for numbered parameters. +# +# It can either restrict the use of numbered parameters to +# single-lined blocks, or disallow completely numbered parameters. +# +# @example EnforcedStyle: allow_single_line (default) +# # bad +# collection.each do +# puts _1 +# end +# +# # good +# collection.each { puts _1 } +# @example EnforcedStyle: disallow +# # bad +# collection.each { puts _1 } +# +# # good +# collection.each { |item| puts item } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters.rb:27 +class RuboCop::Cop::Style::NumberedParameters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters.rb:36 + def on_numblock(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters.rb:31 +RuboCop::Cop::Style::NumberedParameters::MSG_DISALLOW = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters.rb:32 +RuboCop::Cop::Style::NumberedParameters::MSG_MULTI_LINE = T.let(T.unsafe(nil), String) + +# Detects use of an excessive amount of numbered parameters in a +# single block. Having too many numbered parameters can make code too +# cryptic and hard to read. +# +# The cop defaults to registering an offense if there is more than 1 numbered +# parameter but this maximum can be configured by setting `Max`. +# +# @example Max: 1 (default) +# # bad +# foo { _1.call(_2, _3, _4) } +# +# # good +# foo { do_something(_1) } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters_limit.rb:19 +class RuboCop::Cop::Style::NumberedParametersLimit < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def max=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters_limit.rb:30 + def on_numblock(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters_limit.rb:41 + def max_count; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters_limit.rb:23 +RuboCop::Cop::Style::NumberedParametersLimit::DEFAULT_MAX_VALUE = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numbered_parameters_limit.rb:28 +RuboCop::Cop::Style::NumberedParametersLimit::MSG = T.let(T.unsafe(nil), String) + +# Checks for octal, hex, binary, and decimal literals using +# uppercase prefixes and corrects them to lowercase prefix +# or no prefix (in case of decimals). +# +# @example EnforcedOctalStyle: zero_with_o (default) +# # bad - missing octal prefix +# num = 01234 +# +# # bad - uppercase prefix +# num = 0O1234 +# num = 0X12AB +# num = 0B10101 +# +# # bad - redundant decimal prefix +# num = 0D1234 +# num = 0d1234 +# +# # good +# num = 0o1234 +# num = 0x12AB +# num = 0b10101 +# num = 1234 +# @example EnforcedOctalStyle: zero_only +# # bad +# num = 0o1234 +# num = 0O1234 +# +# # good +# num = 01234 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:36 +class RuboCop::Cop::Style::NumericLiteralPrefix < ::RuboCop::Cop::Base + include ::RuboCop::Cop::IntegerNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:52 + def on_int(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:109 + def format_binary(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:113 + def format_decimal(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:105 + def format_hex(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:97 + def format_octal(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:101 + def format_octal_zero_only(source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:82 + def hex_bin_dec_literal_type(literal); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:68 + def literal_type(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:64 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:74 + def octal_literal_type(literal); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:93 + def octal_zero_only?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:49 +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:43 +RuboCop::Cop::Style::NumericLiteralPrefix::BINARY_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:50 +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:44 +RuboCop::Cop::Style::NumericLiteralPrefix::DECIMAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:48 +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:42 +RuboCop::Cop::Style::NumericLiteralPrefix::HEX_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:47 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:41 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:46 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literal_prefix.rb:40 +RuboCop::Cop::Style::NumericLiteralPrefix::OCTAL_ZERO_ONLY_REGEX = T.let(T.unsafe(nil), Regexp) + +# Checks for big numeric literals without `_` between groups +# of digits in them. +# +# Additional allowed patterns can be added by adding regexps to +# the `AllowedPatterns` configuration. All regexps are treated +# as anchored even if the patterns do not contain anchors (so +# `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`). +# +# NOTE: Even if `AllowedPatterns` are given, autocorrection will +# only correct to the standard pattern of an `_` every 3 digits. +# +# @example +# +# # bad +# 1000000 +# 1_00_000 +# 1_0000 +# +# # good +# 1_000_000 +# 1000 +# @example Strict: false (default) +# +# # good +# 10_000_00 # typical representation of $10,000 in cents +# @example Strict: true +# +# # bad +# 10_000_00 # typical representation of $10,000 in cents +# @example AllowedNumbers: [3000] +# +# # good +# 3000 # You can specify allowed numbers. (e.g. port number) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:43 +class RuboCop::Cop::Style::NumericLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::IntegerNode + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:11 + def min_digits=(value); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:60 + def on_float(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:56 + def on_int(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:118 + def allowed_numbers; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:122 + def allowed_patterns; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:66 + def check(node); end + + # @param int_part [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:107 + def format_int_part(int_part); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:93 + def format_number(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:114 + def min_digits; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:82 + def register_offense(node, &_block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:89 + def short_group_regex; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:49 +RuboCop::Cop::Style::NumericLiterals::DELIMITER_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_literals.rb:48 +RuboCop::Cop::Style::NumericLiterals::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of comparison operators (`==`, +# `>`, `<`) to test numbers as zero, positive, or negative. +# These can be replaced by their respective predicate methods. +# This cop can also be configured to do the reverse. +# +# This cop can be customized allowed methods with `AllowedMethods`. +# By default, there are no methods to allowed. +# +# This cop disregards `#nonzero?` as its value is truthy or falsey, +# but not `true` and `false`, and thus not always interchangeable with +# `!= 0`. +# +# This cop allows comparisons to global variables, since they are often +# populated with objects which can be compared with integers, but are +# not themselves `Integer` polymorphic. +# +# @example EnforcedStyle: predicate (default) +# # bad +# foo == 0 +# 0 > foo +# bar.baz > 0 +# +# # good +# foo.zero? +# foo.negative? +# bar.baz.positive? +# @example EnforcedStyle: comparison +# # bad +# foo.zero? +# foo.negative? +# bar.baz.positive? +# +# # good +# foo == 0 +# 0 > foo +# bar.baz > 0 +# @example AllowedMethods: [] (default) with EnforcedStyle: predicate +# # bad +# foo == 0 +# 0 > foo +# bar.baz > 0 +# @example AllowedMethods: [==] with EnforcedStyle: predicate +# # good +# foo == 0 +# +# # bad +# 0 > foo +# bar.baz > 0 +# @example AllowedPatterns: [] (default) with EnforcedStyle: comparison +# # bad +# foo.zero? +# foo.negative? +# bar.baz.positive? +# @example AllowedPatterns: [/zero/] with EnforcedStyle: predicate +# # good +# # bad +# foo.zero? +# +# # bad +# foo.negative? +# bar.baz.positive? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:78 +class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:166 + def comparison(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:171 + def inverted_comparison(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:90 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:161 + def predicate(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:107 + def allowed_method_name?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:111 + def check(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:152 + def invert; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:132 + def parenthesized_source(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:124 + def replacement(numeric, operation); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:144 + def replacement_supported?(operator); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:140 + def require_parentheses?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:84 +RuboCop::Cop::Style::NumericPredicate::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:86 +RuboCop::Cop::Style::NumericPredicate::REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/numeric_predicate.rb:88 +RuboCop::Cop::Style::NumericPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use of consistent method names +# `Object#yield_self` or `Object#then`. +# +# @example EnforcedStyle: then (default) +# +# # bad +# obj.yield_self { |x| x.do_something } +# +# # good +# obj.then { |x| x.do_something } +# @example EnforcedStyle: yield_self +# +# # bad +# obj.then { |x| x.do_something } +# +# # good +# obj.yield_self { |x| x.do_something } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:25 +class RuboCop::Cop::Style::ObjectThen < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:31 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:31 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:37 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:45 + def check_method_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:65 + def message(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:54 + def preferred_method(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/object_then.rb:29 +RuboCop::Cop::Style::ObjectThen::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of if/then/else/end constructs on a single line. +# AlwaysCorrectToMultiline config option can be set to true to auto-convert all offenses to +# multi-line constructs. When AlwaysCorrectToMultiline is false (default case) the +# autocorrect will first try converting them to ternary operators. +# +# @example +# # bad +# if foo then bar else baz end +# +# # bad +# unless foo then baz else bar end +# +# # good +# foo ? bar : baz +# +# # good +# bar if foo +# +# # good +# if foo then bar end +# +# # good +# if foo +# bar +# else +# baz +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:33 +class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::OnNormalIfUnless + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:41 + def on_normal_if_unless(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:76 + def always_multiline?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:58 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:80 + def cannot_replace_to_ternary?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:92 + def expr_replacement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:120 + def indentation_width; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:113 + def keyword_with_changed_precedence?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:54 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:106 + def method_call_with_changed_precedence?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:98 + def requires_parentheses?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:66 + def ternary_correction(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:84 + def ternary_replacement(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/one_line_conditional.rb:38 +RuboCop::Cop::Style::OneLineConditional::MSG = T.let(T.unsafe(nil), String) + +# Flags uses of OpenStruct, as it is now officially discouraged +# to be used for performance, version compatibility, and potential security issues. +# +# @example +# +# # bad +# point = OpenStruct.new(x: 0, y: 1) +# +# # good +# Point = Struct.new(:x, :y) +# point = Point.new(0, 1) +# +# # also good +# point = { x: 0, y: 1 } +# +# # bad +# test_double = OpenStruct.new(a: 'b') +# +# # good (assumes test using rspec-mocks) +# test_double = double +# allow(test_double).to receive(:a).and_return('b') +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/open_struct_use.rb:44 +class RuboCop::Cop::Style::OpenStructUse < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/open_struct_use.rb:52 + def on_const(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/open_struct_use.rb:48 + def uses_open_struct?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/open_struct_use.rb:61 + def custom_class_or_module_definition?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/open_struct_use.rb:45 +RuboCop::Cop::Style::OpenStructUse::MSG = T.let(T.unsafe(nil), String) + +# Checks for options hashes and discourages them if the +# current Ruby version supports keyword arguments. +# +# @example +# +# # bad +# def fry(options = {}) +# temperature = options.fetch(:temperature, 300) +# # ... +# end +# +# # good +# def fry(temperature: 300) +# # ... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:22 +class RuboCop::Cop::Style::OptionHash < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:30 + def on_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:26 + def option_hash(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:39 + def allowlist; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:48 + def super_used?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:43 + def suspicious_name?(arg_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/option_hash.rb:23 +RuboCop::Cop::Style::OptionHash::MSG = T.let(T.unsafe(nil), String) + +# Checks for optional arguments to methods +# that do not come at the end of the argument list. +# +# @example +# # bad +# def foo(a = 1, b, c) +# end +# +# # good +# def baz(a, b, c = 1) +# end +# +# def foobar(a = 1, b = 2, c = 3) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/optional_arguments.rb:24 +class RuboCop::Cop::Style::OptionalArguments < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_arguments.rb:27 + def on_def(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_arguments.rb:45 + def argument_positions(arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_arguments.rb:33 + def each_misplaced_optional_arg(arguments); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/optional_arguments.rb:25 +RuboCop::Cop::Style::OptionalArguments::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where keyword arguments can be used instead of +# boolean arguments when defining methods. `respond_to_missing?` method is allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example +# # bad +# def some_method(bar = false) +# puts bar +# end +# +# # bad - common hack before keyword args were introduced +# def some_method(options = {}) +# bar = options.fetch(:bar, false) +# puts bar +# end +# +# # good +# def some_method(bar: false) +# puts bar +# end +# @example AllowedMethods: ['some_method'] +# # good +# def some_method(bar = false) +# puts bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/optional_boolean_parameter.rb:37 +class RuboCop::Cop::Style::OptionalBooleanParameter < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_boolean_parameter.rb:43 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_boolean_parameter.rb:43 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/optional_boolean_parameter.rb:56 + def format_message(argument); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/optional_boolean_parameter.rb:40 +RuboCop::Cop::Style::OptionalBooleanParameter::MSG = T.let(T.unsafe(nil), String) + +# Checks for potential usage of the `||=` operator. +# +# @example +# # bad +# name = name ? name : 'Bozhidar' +# +# # bad +# name = if name +# name +# else +# 'Bozhidar' +# end +# +# # bad +# unless name +# name = 'Bozhidar' +# end +# +# # bad +# name = 'Bozhidar' unless name +# +# # good - set name to 'Bozhidar', only if it's nil or false +# name ||= 'Bozhidar' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:29 +class RuboCop::Cop::Style::OrAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:57 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:57 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:51 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:57 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:57 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:35 + def ternary_assignment?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:44 + def unless_assignment?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:70 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:80 + def take_variable_and_default_from_ternary(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:85 + def take_variable_and_default_from_unless(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/or_assignment.rb:32 +RuboCop::Cop::Style::OrAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for simple usages of parallel assignment. +# This will only complain when the number of variables +# being assigned matched the number of assigning variables. +# +# @example +# # bad +# a, b, c = 1, 2, 3 +# a, b, c = [1, 2, 3] +# +# # good +# one, two = *foo +# a, b = foo() +# a, b = b, a +# +# a = 1 +# b = 2 +# c = 3 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:25 +class RuboCop::Cop::Style::ParallelAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:115 + def implicit_self_getter?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:31 + def on_masgn(node); end + + private + + # Converts (send nil :something) nodes to (send (:self) :something). + # This makes the sorting algorithm work for expressions such as + # `self.a, self.b = b, a`. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:108 + def add_self_to_getters(right_elements); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:60 + def allowed_lhs?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:54 + def allowed_masign?(lhs_elements, rhs_elements); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:68 + def allowed_rhs?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:80 + def assignment_corrector(node, order); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:44 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:91 + def find_valid_order(left_elements, right_elements); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:174 + def modifier_statement?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:76 + def return_of_method_call?(node); end +end + +# Helper class necessitated by silly design of TSort prior to Ruby 2.1 +# Newer versions have a better API, but that doesn't help us +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:119 +class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter + include ::TSort + extend ::RuboCop::AST::NodePattern::Macros + + # @return [AssignmentSorter] a new instance of AssignmentSorter + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:132 + def initialize(assignments); end + + # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`. + # Does `rhs` access the same value which is assigned by `lhs`? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:161 + def accesses?(rhs, lhs); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:154 + def dependency?(lhs, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:130 + def matching_calls(param0, param1, param2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:140 + def tsort_each_child(assignment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:136 + def tsort_each_node(&block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:127 + def uses_var?(param0, param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:124 + def var_name(param0 = T.unsafe(nil)); end +end + +# An internal class for correcting parallel assignment +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:179 +class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + include ::RuboCop::Cop::Alignment + + # @return [GenericCorrector] a new instance of GenericCorrector + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:184 + def initialize(node, config, new_elements); end + + # Returns the value of attribute config. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:182 + def config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:190 + def correction; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:194 + def correction_range; end + + # Returns the value of attribute node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:182 + def node; end + + protected + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:200 + def assignment; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:220 + def cop_config; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:216 + def extract_sources(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:206 + def source(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:29 +RuboCop::Cop::Style::ParallelAssignment::MSG = T.let(T.unsafe(nil), String) + +# An internal class for correcting parallel assignment +# guarded by if, unless, while, or until +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:265 +class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:266 + def correction; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:275 + def correction_range; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:281 + def modifier_range(node); end +end + +# An internal class for correcting parallel assignment +# protected by rescue +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:227 +class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector < ::RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:228 + def correction; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:242 + def correction_range; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:253 + def begin_correction(rescue_result); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parallel_assignment.rb:248 + def def_correction(rescue_result); end +end + +# Checks for the presence of superfluous parentheses around the +# condition of if/unless/while/until. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example +# # bad +# x += 1 while (x < 10) +# foo unless (bar || baz) +# +# if (x > 10) +# elsif (x < 3) +# end +# +# # good +# x += 1 while x < 10 +# foo unless bar || baz +# +# if x > 10 +# elsif x < 3 +# end +# @example AllowSafeAssignment: true (default) +# # good +# foo unless (bar = baz) +# @example AllowSafeAssignment: false +# # bad +# foo unless (bar = baz) +# @example AllowInMultilineConditions: false (default) +# # bad +# if (x > 10 && +# y > 10) +# end +# +# # good +# if x > 10 && +# y > 10 +# end +# @example AllowInMultilineConditions: true +# # good +# if (x > 10 && +# y > 10) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:56 +class RuboCop::Cop::Style::ParenthesesAroundCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::Parentheses + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:76 + def control_op_condition(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:62 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:68 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:68 + def on_while(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:122 + def allow_multiline_conditions?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:110 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:103 + def modifier_op?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:116 + def parens_allowed?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:80 + def process_control_op(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/parentheses_around_condition.rb:95 + def semicolon_separated_expressions?(first_exp, rest_exps); end +end + +# Enforces the consistent usage of `%`-literal delimiters. +# +# Specify the 'default' key to set all preferred delimiters at once. You +# can continue to specify individual preferred delimiters to override the +# default. +# +# @example +# # Style/PercentLiteralDelimiters: +# # PreferredDelimiters: +# # default: '[]' +# # '%i': '()' +# +# # good +# %w[alpha beta] + %i(gamma delta) +# +# # bad +# %W(alpha #{beta}) +# +# # bad +# %I(alpha beta) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:26 +class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:30 + def on_array(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:38 + def on_dstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:34 + def on_regexp(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:38 + def on_str(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:43 + def on_sym(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:47 + def on_xstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:93 + def contains_delimiter?(node, delimiters); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:82 + def contains_preferred_delimiter?(node, type); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:86 + def include_same_character_as_used_for_delimiter?(node, type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:108 + def matchpairs(begin_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:67 + def message(type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:53 + def on_percent_literal(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:74 + def preferred_delimiters_for(type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:100 + def string_source(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_literal_delimiters.rb:78 + def uses_preferred_delimiter?(node, type); end +end + +# Checks for usage of the %Q() syntax when %q() would do. +# +# @example EnforcedStyle: lower_case_q (default) +# # The `lower_case_q` style prefers `%q` unless +# # interpolation is needed. +# # bad +# %Q[Mix the foo into the baz.] +# %Q(They all said: 'Hooray!') +# +# # good +# %q[Mix the foo into the baz] +# %q(They all said: 'Hooray!') +# @example EnforcedStyle: upper_case_q +# # The `upper_case_q` style requires the sole use of `%Q`. +# # bad +# %q/Mix the foo into the baz./ +# %q{They all said: 'Hooray!'} +# +# # good +# %Q/Mix the foo into the baz./ +# %Q{They all said: 'Hooray!'} +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:28 +class RuboCop::Cop::Style::PercentQLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:36 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:55 + def correct_literal_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:64 + def corrected(src); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:60 + def message(_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:42 + def on_percent_literal(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:33 +RuboCop::Cop::Style::PercentQLiterals::LOWER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/percent_q_literals.rb:34 +RuboCop::Cop::Style::PercentQLiterals::UPPER_CASE_Q_MSG = T.let(T.unsafe(nil), String) + +# Looks for uses of Perl-style regexp match +# backreferences and their English versions like +# $1, $2, $&, &+, $MATCH, $PREMATCH, etc. +# +# @example +# # bad +# puts $1 +# +# # good +# puts Regexp.last_match(1) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:16 +class RuboCop::Cop::Style::PerlBackrefs < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:21 + def on_back_ref(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:25 + def on_gvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:29 + def on_nth_ref(node); end + + private + + # @param node [RuboCop::AST::Node] + # @private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:38 + def derived_from_braceless_interpolation?(node); end + + # @param node [RuboCop::AST::Node] + # @param preferred_expression [String] + # @private + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:46 + def format_message(node:, preferred_expression:); end + + # @param node [RuboCop::AST::Node] + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:88 + def on_back_ref_or_gvar_or_nth_ref(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:58 + def original_expression_of(node); end + + # @param node [RuboCop::AST::Node] + # @private + # @return [String, nil] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:70 + def preferred_expression_to(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/perl_backrefs.rb:19 +RuboCop::Cop::Style::PerlBackrefs::MESSAGE_FORMAT = T.let(T.unsafe(nil), String) + +# Checks for uses of methods `Hash#has_key?` and +# `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead. +# +# It is configurable to enforce the verbose method names, by using the +# `EnforcedStyle: verbose` configuration. +# +# @example EnforcedStyle: short (default) +# # bad +# Hash#has_key? +# Hash#has_value? +# +# # good +# Hash#key? +# Hash#value? +# @example EnforcedStyle: verbose +# # bad +# Hash#key? +# Hash#value? +# +# # good +# Hash#has_key? +# Hash#has_value? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:33 +class RuboCop::Cop::Style::PreferredHashMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:43 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:43 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:56 + def message(method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:68 + def offending_selector?(method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:60 + def proper_method_name(method_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:37 +RuboCop::Cop::Style::PreferredHashMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:39 +RuboCop::Cop::Style::PreferredHashMethods::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/preferred_hash_methods.rb:41 +RuboCop::Cop::Style::PreferredHashMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of Proc.new where Kernel#proc +# would be more appropriate. +# +# @example +# # bad +# p = Proc.new { |n| puts n } +# +# # good +# p = proc { |n| puts n } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/proc.rb:16 +class RuboCop::Cop::Style::Proc < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/proc.rb:25 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/proc.rb:25 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/proc.rb:22 + def proc_new?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/proc.rb:19 +RuboCop::Cop::Style::Proc::MSG = T.let(T.unsafe(nil), String) + +# Checks if the quotes used for quoted symbols match the configured defaults. +# By default uses the same configuration as `Style/StringLiterals`; if that +# cop is not enabled, the default `EnforcedStyle` is `single_quotes`. +# +# String interpolation is always kept in double quotes. +# +# Note: `Lint/SymbolConversion` can be used in parallel to ensure that symbols +# are not quoted that don't need to be. This cop is for configuring the quoting +# style to use for symbols that require quotes. +# +# @example EnforcedStyle: same_as_string_literals (default) / single_quotes +# # bad +# :"abc-def" +# +# # good +# :'abc-def' +# :"#{str}" +# :"a\'b" +# @example EnforcedStyle: double_quotes +# # bad +# :'abc-def' +# +# # good +# :"abc-def" +# :"#{str}" +# :"a\'b" +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:33 +class RuboCop::Cop::Style::QuotedSymbols < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SymbolHelp + include ::RuboCop::Cop::StringLiteralsHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:44 + def on_sym(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:108 + def alternative_style; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:71 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:88 + def correct_quotes(str); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:83 + def hash_colon_key?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:61 + def invalid_double_quotes?(source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:112 + def quoted?(sym_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:99 + def style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:116 + def wrong_quotes?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:41 +RuboCop::Cop::Style::QuotedSymbols::MSG_DOUBLE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/quoted_symbols.rb:39 +RuboCop::Cop::Style::QuotedSymbols::MSG_SINGLE = T.let(T.unsafe(nil), String) + +# Checks the args passed to `fail` and `raise`. For exploded +# style (default), it recommends passing the exception class and message +# to `raise`, rather than construct an instance of the error. It will +# still allow passing just a message, or the construction of an error +# with more than one argument. +# +# The exploded style works identically, but with the addition that it +# will also suggest constructing error objects when the exception is +# passed multiple arguments. +# +# The exploded style has an `AllowedCompactTypes` configuration +# option that takes an Array of exception name Strings. +# +# @example EnforcedStyle: exploded (default) +# # bad +# raise StandardError.new('message') +# +# # good +# raise StandardError, 'message' +# fail 'message' +# raise MyCustomError +# raise MyCustomError.new(arg1, arg2, arg3) +# raise MyKwArgError.new(key1: val1, key2: val2) +# +# # With `AllowedCompactTypes` set to ['MyWrappedError'] +# raise MyWrappedError.new(obj) +# raise MyWrappedError.new(obj), 'message' +# @example EnforcedStyle: compact +# # bad +# raise StandardError, 'message' +# raise RuntimeError, arg1, arg2, arg3 +# +# # good +# raise StandardError.new('message') +# raise MyCustomError +# raise MyCustomError.new(arg1, arg2, arg3) +# fail 'message' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:44 +class RuboCop::Cop::Style::RaiseArgs < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:53 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:129 + def acceptable_exploded_args?(args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:143 + def allowed_non_exploded_type?(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:92 + def check_compact(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:108 + def check_exploded(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:66 + def correction_compact_to_exploded(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:78 + def correction_exploded_to_compact(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:149 + def requires_parens?(parent); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:125 + def use_new_method?(first_arg); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:49 +RuboCop::Cop::Style::RaiseArgs::COMPACT_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:48 +RuboCop::Cop::Style::RaiseArgs::EXPLODED_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/raise_args.rb:51 +RuboCop::Cop::Style::RaiseArgs::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of randomly generated numbers, +# added/subtracted with integer literals, as well as those with +# Integer#succ and Integer#pred methods. Prefer using ranges instead, +# as it clearly states the intentions. +# +# @example +# # bad +# rand(6) + 1 +# 1 + rand(6) +# rand(6) - 1 +# 1 - rand(6) +# rand(6).succ +# rand(6).pred +# Random.rand(6) + 1 +# Kernel.rand(6) + 1 +# rand(0..5) + 1 +# +# # good +# rand(1..6) +# rand(1...7) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:26 +class RuboCop::Cop::Style::RandomWithOffset < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:33 + def integer_op_rand?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:63 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:54 + def rand_modified?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:43 + def rand_op_integer?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:73 + def random_call(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:147 + def to_int(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:78 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:135 + def boundaries_from_random_node(random_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:88 + def corrected_integer_op_rand(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:118 + def corrected_rand_modified(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:103 + def corrected_rand_op_integer(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:131 + def prefix_from_prefix_node(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:29 +RuboCop::Cop::Style::RandomWithOffset::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/random_with_offset.rb:30 +RuboCop::Cop::Style::RandomWithOffset::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for a redundant argument passed to certain methods. +# +# NOTE: This cop is limited to methods with single parameter. +# +# Method names and their redundant arguments can be configured like this: +# +# [source,yaml] +# ---- +# Methods: +# join: '' +# split: ' ' +# chomp: "\n" +# chomp!: "\n" +# foo: 2 +# ---- +# +# @example +# # bad +# array.join('') +# [1, 2, 3].join("") +# string.split(" ") +# "first\nsecond".split(" ") +# string.chomp("\n") +# string.chomp!("\n") +# A.foo(2) +# +# # good +# array.join +# [1, 2, 3].join +# string.split +# "first second".split +# string.chomp +# string.chomp! +# A.foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:50 +class RuboCop::Cop::Style::RedundantArgument < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:56 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:85 + def argument_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:78 + def redundant_arg_for_method(method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:71 + def redundant_argument?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_argument.rb:54 +RuboCop::Cop::Style::RedundantArgument::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant assignment before returning. +# +# @example +# # bad +# def test +# x = foo +# x +# end +# +# # bad +# def test +# if x +# z = foo +# z +# elsif y +# z = bar +# z +# end +# end +# +# # good +# def test +# foo +# end +# +# # good +# def test +# if x +# foo +# elsif y +# bar +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:40 +class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:50 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:50 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:46 + def redundant_assignment?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:91 + def check_begin_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:57 + def check_branch(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:71 + def check_case_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:87 + def check_ensure_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:76 + def check_if_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:83 + def check_rescue_node(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_assignment.rb:43 +RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant `begin` blocks. +# +# Currently it checks for code like this: +# +# @example +# +# # bad +# def redundant +# begin +# ala +# bala +# rescue StandardError => e +# something +# end +# end +# +# # good +# def preferred +# ala +# bala +# rescue StandardError => e +# something +# end +# +# # bad +# begin +# do_something +# end +# +# # good +# do_something +# +# # bad +# # When using Ruby 2.5 or later. +# do_something do +# begin +# something +# rescue => ex +# anything +# end +# end +# +# # good +# # In Ruby 2.5 or later, you can omit `begin` in `do-end` block. +# do_something do +# something +# rescue => ex +# anything +# end +# +# # good +# # Stabby lambdas don't support implicit `begin` in `do-end` blocks. +# -> do +# begin +# foo +# rescue Bar +# baz +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:65 +class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:72 + def offensive_kwbegins(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:83 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:76 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:76 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:94 + def on_kwbegin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:83 + def on_numblock(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:102 + def allowable_kwbegin?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:168 + def begin_block_has_multiline_statements?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:160 + def condition_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:172 + def contain_rescue_or_ensure?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:153 + def correct_modifier_form_after_multiline_begin_block(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:164 + def empty_begin?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:109 + def register_offense(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:126 + def replace_begin_with_statement(corrector, offense_range, node); end + + # Restore comments that occur between "begin" and "first_child". + # These comments will be moved to above the assignment line. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:140 + def restore_removed_comments(corrector, offense_range, node, first_child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:147 + def use_modifier_form_after_multiline_begin_block?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:185 + def valid_begin_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:178 + def valid_context_using_only_begin?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_begin.rb:69 +RuboCop::Cop::Style::RedundantBegin::MSG = T.let(T.unsafe(nil), String) + +# Checks for usage of the %W() syntax when %w() would do. +# +# @example +# # bad +# %W(cat dog pig) +# %W[door wall floor] +# +# # good +# %w/swim run bike/ +# %w[shirt pants shoes] +# %W(apple #{fruit} grape) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_capital_w.rb:17 +class RuboCop::Cop::Style::RedundantCapitalW < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_capital_w.rb:23 + def on_array(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_capital_w.rb:29 + def on_percent_literal(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_capital_w.rb:38 + def requires_interpolation?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_capital_w.rb:21 +RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String) + +# Checks for unnecessary conditional expressions. +# +# @example +# # bad +# a = b ? b : c +# +# # good +# a = b || c +# @example +# # bad +# if b +# b +# else +# c +# end +# +# # good +# b || c +# +# # good +# if b +# b +# elsif cond +# c +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:33 +class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:40 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:139 + def asgn_type?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:129 + def branches_have_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:143 + def branches_have_method?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:222 + def correct_ternary(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:169 + def else_source(else_branch, arithmetic_operation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:195 + def else_source_if_has_assignment(else_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:185 + def else_source_if_has_method(else_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:157 + def if_source(if_branch, arithmetic_operation); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:205 + def make_ternary_form(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:61 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:76 + def offense?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:69 + def range_of_offense(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:85 + def redundant_condition?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:237 + def require_braces?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:230 + def require_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:153 + def same_method?(if_branch, else_branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:101 + def synonymous_condition_and_branch?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:241 + def use_arithmetic_operation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:97 + def use_hash_key_access?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:93 + def use_hash_key_assignment?(else_branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:89 + def use_if_branch?(else_branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:245 + def without_argument_parentheses_method?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:37 +RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_condition.rb:38 +RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String) + +# Checks for redundant returning of true/false in conditionals. +# +# @example +# # bad +# x == y ? true : false +# +# # bad +# if x == y +# true +# else +# false +# end +# +# # good +# x == y +# +# # bad +# x == y ? false : true +# +# # good +# x != y +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:27 +class RuboCop::Cop::Style::RedundantConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:36 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:56 + def redundant_condition?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:61 + def redundant_condition_inverted?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:90 + def configured_indentation_width; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:86 + def indented_else_node(expression, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:78 + def invert_expression?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:48 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:65 + def offense?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:71 + def replacement_condition(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:32 +RuboCop::Cop::Style::RedundantConditional::COMPARISON_OPERATOR_MATCHER = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_conditional.rb:34 +RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String) + +# Checks for RuntimeError as the argument of raise/fail. +# +# It checks for code like this: +# +# @example +# # Bad +# raise RuntimeError, 'message' +# +# # Bad +# raise RuntimeError.new('message') +# +# # Good +# raise 'message' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:19 +class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:59 + def compact?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:54 + def exploded?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:45 + def fix_compact(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:33 + def fix_exploded(node); end + + # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and + # `raise RuntimeError.new('message')` to `raise 'message'`. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:29 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:22 +RuboCop::Cop::Style::RedundantException::MSG_1 = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:23 +RuboCop::Cop::Style::RedundantException::MSG_2 = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_exception.rb:25 +RuboCop::Cop::Style::RedundantException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `fetch(key) { value }` +# can be replaced by `fetch(key, value)`. +# +# In such cases `fetch(key, value)` method is faster +# than `fetch(key) { value }`. +# +# @example SafeForConstants: false (default) +# # bad +# hash.fetch(:key) { 5 } +# hash.fetch(:key) { true } +# hash.fetch(:key) { nil } +# array.fetch(5) { :value } +# ENV.fetch(:key) { 'value' } +# +# # good +# hash.fetch(:key, 5) +# hash.fetch(:key, true) +# hash.fetch(:key, nil) +# array.fetch(5, :value) +# ENV.fetch(:key, 'value') +# @example SafeForConstants: true +# # bad +# ENV.fetch(:key) { VALUE } +# +# # good +# ENV.fetch(:key, VALUE) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:38 +class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:53 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:87 + def rails_cache?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:46 + def redundant_fetch_block_candidate?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:72 + def basic_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:102 + def build_bad_method(send, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:95 + def build_good_method(send, body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:109 + def check_for_constant?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:113 + def check_for_string?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:76 + def const_type?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:91 + def fetch_range(send, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:80 + def should_not_check?(send, body); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_fetch_block.rb:43 +RuboCop::Cop::Style::RedundantFetchBlock::MSG = T.let(T.unsafe(nil), String) + +# Checks for the presence of superfluous `.rb` extension in +# the filename provided to `require` and `require_relative`. +# +# Note: If the extension is omitted, Ruby tries adding '.rb', '.so', +# and so on to the name until found. If the file named cannot be found, +# a `LoadError` will be raised. +# There is an edge case where `foo.so` file is loaded instead of a `LoadError` +# if `foo.so` file exists when `require 'foo.rb'` will be changed to `require 'foo'`, +# but that seems harmless. +# +# @example +# # bad +# require 'foo.rb' +# require_relative '../foo.rb' +# +# # good +# require 'foo' +# require 'foo.so' +# require_relative '../foo' +# require_relative '../foo.so' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:27 +class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:39 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:35 + def require_call?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:53 + def extension_range(name_node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:31 +RuboCop::Cop::Style::RedundantFileExtensionInRequire::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_file_extension_in_require.rb:32 +RuboCop::Cop::Style::RedundantFileExtensionInRequire::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Check for uses of `Object#freeze` on immutable objects. +# +# NOTE: Regexp and Range literals are frozen objects since Ruby 3.0. +# +# NOTE: From Ruby 3.0, this cop allows explicit freezing of interpolated +# string literals when `# frozen-string-literal: true` is used. +# +# @example +# # bad +# CONST = 1.freeze +# +# # good +# CONST = 1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:19 +class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base + include ::RuboCop::Cop::FrozenStringLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:26 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:57 + def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:39 + def immutable_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:48 + def strip_parenthesis(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:23 +RuboCop::Cop::Style::RedundantFreeze::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_freeze.rb:24 +RuboCop::Cop::Style::RedundantFreeze::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for `initialize` methods that are redundant. +# +# An initializer is redundant if it does not do anything, or if it only +# calls `super` with the same arguments given to it. If the initializer takes +# an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it +# will not register an offense, because it allows the initializer to take a different +# number of arguments as its superclass potentially does. +# +# NOTE: If an initializer argument has a default value, RuboCop assumes it +# to *not* be redundant. +# +# NOTE: Empty initializers are registered as offenses, but it is possible +# to purposely create an empty `initialize` method to override a superclass's +# initializer. +# +# @example +# # bad +# def initialize +# end +# +# # bad +# def initialize +# super +# end +# +# # bad +# def initialize(a, b) +# super +# end +# +# # bad +# def initialize(a, b) +# super(a, b) +# end +# +# # good +# def initialize +# do_something +# end +# +# # good +# def initialize +# do_something +# super +# end +# +# # good (different number of parameters) +# def initialize(a, b) +# super(a) +# end +# +# # good (default value) +# def initialize(a, b = 5) +# super +# end +# +# # good (default value) +# def initialize(a, b: 5) +# super +# end +# +# # good (changes the parameter requirements) +# def initialize(*) +# end +# +# # good (changes the parameter requirements) +# def initialize(**) +# end +# +# # good (changes the parameter requirements) +# def initialize(...) +# end +# @example AllowComments: true (default) +# +# # good +# def initialize +# # Overriding to negate superclass `initialize` method. +# end +# @example AllowComments: false +# +# # bad +# def initialize +# # Overriding to negate superclass `initialize` method. +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:97 +class RuboCop::Cop::Style::RedundantInitialize < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:106 + def initialize_forwards?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:110 + def on_def(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:134 + def acceptable?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:142 + def allow_comments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:138 + def forwards?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:128 + def register_offense(node, message); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:146 + def same_args?(super_node, args); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:102 +RuboCop::Cop::Style::RedundantInitialize::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_initialize.rb:103 +RuboCop::Cop::Style::RedundantInitialize::MSG_EMPTY = T.let(T.unsafe(nil), String) + +# Checks for strings that are just an interpolated expression. +# +# @example +# +# # bad +# "#{@var}" +# +# # good +# @var.to_s +# +# # good if @var is already a String +# @var +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:39 +class RuboCop::Cop::Style::RedundantInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::PercentLiteral + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:49 + def on_dstr(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:122 + def autocorrect_other(corrector, embedded_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:105 + def autocorrect_single_variable_interpolation(corrector, embedded_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:99 + def autocorrect_variable_interpolation(corrector, embedded_node, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:95 + def embedded_in_percent_array?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:91 + def implicit_concatenation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:83 + def interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:132 + def require_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:67 + def single_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:74 + def single_variable_interpolation?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:87 + def variable_interpolation?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:45 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_interpolation.rb:43 +RuboCop::Cop::Style::RedundantInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant parentheses. +# +# @example +# +# # bad +# (x) if ((y.z).nil?) +# +# # good +# x if y.z.nil? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:16 +class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Parentheses + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:33 + def arg_in_call_with_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:216 + def first_send_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:221 + def first_super_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:226 + def first_yield_argument?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:134 + def interpolation?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:27 + def method_node_and_args(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:35 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:24 + def range_end?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:30 + def rescue?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:21 + def square_brackets?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:64 + def allowed_ancestor?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:57 + def allowed_expression?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:69 + def allowed_method_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:74 + def allowed_multiple_expression?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:83 + def allowed_ternary?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:230 + def call_chain_starts_with_int?(begin_node, send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:121 + def check(begin_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:136 + def check_send(begin_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:145 + def check_unary(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:169 + def disallowed_literal?(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:101 + def empty_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:106 + def first_arg_begins_with_hash_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:211 + def first_argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:50 + def ignore_syntax?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:165 + def keyword_ancestor?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:184 + def keyword_with_redundant_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:96 + def like_method_argument_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:197 + def method_call_with_redundant_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:113 + def method_chain_begins_with_hash_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:155 + def offense(node, msg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:207 + def only_begin_arg?(args); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:43 + def parens_allowed?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:173 + def raised_to_power_negative_numeric?(begin_node, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:161 + def suspect_unary?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_parentheses.rb:89 + def ternary_parentheses_required?; end +end + +# Checks for usage of the %q/%Q syntax when '' or "" would do. +# +# @example +# +# # bad +# name = %q(Bruce Wayne) +# time = %q(8 o'clock) +# question = %q("What did you say?") +# +# # good +# name = 'Bruce Wayne' +# time = "8 o'clock" +# question = '"What did you say?"' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:20 +class RuboCop::Cop::Style::RedundantPercentQ < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:34 + def on_dstr(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:40 + def on_str(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:99 + def acceptable_capital_q?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:91 + def acceptable_q?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:67 + def allowed_percent_q?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:51 + def check(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:63 + def interpolated_quotes?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:72 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:87 + def start_with_percent_q_variant?(string); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:82 + def string_literal?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:25 +RuboCop::Cop::Style::RedundantPercentQ::DYNAMIC_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:28 +RuboCop::Cop::Style::RedundantPercentQ::EMPTY = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:32 +RuboCop::Cop::Style::RedundantPercentQ::ESCAPED_NON_BACKSLASH = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:23 +RuboCop::Cop::Style::RedundantPercentQ::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:30 +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_CAPITAL_Q = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:29 +RuboCop::Cop::Style::RedundantPercentQ::PERCENT_Q = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:27 +RuboCop::Cop::Style::RedundantPercentQ::QUOTE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:26 +RuboCop::Cop::Style::RedundantPercentQ::SINGLE_QUOTE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_percent_q.rb:31 +RuboCop::Cop::Style::RedundantPercentQ::STRING_INTERPOLATION_REGEXP = T.let(T.unsafe(nil), Regexp) + +# Checks for unnecessary single-element Regexp character classes. +# +# @example +# +# # bad +# r = /[x]/ +# +# # good +# r = /x/ +# +# # bad +# r = /[\s]/ +# +# # good +# r = /\s/ +# +# # bad +# r = %r{/[b]} +# +# # good +# r = %r{/b} +# +# # good +# r = /[ab]/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:30 +class RuboCop::Cop::Style::RedundantRegexpCharacterClass < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:37 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:101 + def backslash_b?(elem); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:53 + def each_redundant_character_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:61 + def each_single_element_character_class(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:83 + def multiple_codepoins?(expression); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:72 + def redundant_single_element_character_class?(node, char_class); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:107 + def requires_escape_outside_char_class?(elem); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:95 + def whitespace_in_free_space_mode?(node, elem); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:87 + def without_character_class(loc); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:34 +RuboCop::Cop::Style::RedundantRegexpCharacterClass::MSG_REDUNDANT_CHARACTER_CLASS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_character_class.rb:33 +RuboCop::Cop::Style::RedundantRegexpCharacterClass::REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = T.let(T.unsafe(nil), Array) + +# Checks for redundant escapes inside Regexp literals. +# +# @example +# # bad +# %r{foo\/bar} +# +# # good +# %r{foo/bar} +# +# # good +# /foo\/bar/ +# +# # good +# %r/foo\/bar/ +# +# # good +# %r!foo\!bar! +# +# # bad +# /a\-b/ +# +# # good +# /a-b/ +# +# # bad +# /[\+\-]\d/ +# +# # good +# /[+\-]\d/ +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:35 +class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:45 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:59 + def allowed_escape?(node, char, within_character_class); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:74 + def delimiter?(node, char); end + + # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. + # It's for compatibility with regexp_arser 1.8 and will never be maintained. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:81 + def each_escape(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:108 + def escape_range_at_index(node, index); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:41 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_ALWAYS_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:43 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:42 +RuboCop::Cop::Style::RedundantRegexpEscape::ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_regexp_escape.rb:39 +RuboCop::Cop::Style::RedundantRegexpEscape::MSG_REDUNDANT_ESCAPE = T.let(T.unsafe(nil), String) + +# Checks for redundant `return` expressions. +# +# @example +# # These bad cases should be extended to handle methods whose body is +# # if/else or a case expression with a default branch. +# +# # bad +# def test +# return something +# end +# +# # bad +# def test +# one +# two +# three +# return something +# end +# +# # good +# def test +# return something if something_else +# end +# +# # good +# def test +# if x +# elsif y +# else +# end +# end +# @example AllowMultipleReturnValues: false (default) +# # bad +# def test +# return x, y +# end +# @example AllowMultipleReturnValues: true +# # good +# def test +# return x, y +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:50 +class RuboCop::Cop::Style::RedundantReturn < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:57 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:57 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:92 + def add_braces(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:87 + def add_brackets(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:157 + def allow_multiple_return_values?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:152 + def check_begin_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:98 + def check_branch(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:126 + def check_case_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:147 + def check_ensure_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:131 + def check_if_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:143 + def check_resbody_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:138 + def check_rescue_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:114 + def check_return_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:68 + def correct_with_arguments(return_node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:64 + def correct_without_arguments(return_node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:83 + def hash_without_braces?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:161 + def message(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:54 +RuboCop::Cop::Style::RedundantReturn::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_return.rb:55 +RuboCop::Cop::Style::RedundantReturn::MULTI_RETURN_MSG = T.let(T.unsafe(nil), String) + +# Checks for redundant uses of `self`. +# +# The usage of `self` is only needed when: +# +# * Sending a message to same object with zero arguments in +# presence of a method name clash with an argument or a local +# variable. +# +# * Calling an attribute writer to prevent a local variable assignment. +# +# Note, with using explicit self you can only send messages with public or +# protected scope, you cannot send private messages this way. +# +# Note we allow uses of `self` with operators because it would be awkward +# otherwise. +# +# @example +# +# # bad +# def foo(bar) +# self.baz +# end +# +# # good +# def foo(bar) +# self.bar # Resolves name clash with the argument. +# end +# +# def foo +# bar = 1 +# self.bar # Resolves name clash with the local variable. +# end +# +# def foo +# %w[x y z].select do |bar| +# self.bar == bar # Resolves name clash with argument of the block. +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:44 +class RuboCop::Cop::Style::RedundantSelf < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # @return [RedundantSelf] a new instance of RedundantSelf + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:59 + def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end + + # Assignment of self.x + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:67 + def on_and_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:85 + def on_args(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:119 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:89 + def on_blockarg(node); end + + # Using self.x to distinguish from local variable x + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:80 + def on_def(node); end + + # Using self.x to distinguish from local variable x + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:80 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:125 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:103 + def on_in_pattern(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:98 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:93 + def on_masgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:119 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:73 + def on_op_asgn(node); end + + # Assignment of self.x + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:67 + def on_or_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:107 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:125 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:125 + def on_while(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:181 + def add_lhs_to_local_variables_scopes(rhs, lhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:189 + def add_masgn_lhs_variables(rhs, lhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:195 + def add_match_var_scopes(in_pattern_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:143 + def add_scope(node, local_variables = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:175 + def allow_self(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:149 + def allowed_send_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:166 + def on_argument(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:158 + def regular_method_call?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:55 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:48 +RuboCop::Cop::Style::RedundantSelf::KERNEL_METHODS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:49 +RuboCop::Cop::Style::RedundantSelf::KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self.rb:47 +RuboCop::Cop::Style::RedundantSelf::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where redundant assignments are made for in place +# modification methods. +# +# @example +# # bad +# args = args.concat(ary) +# hash = hash.merge!(other) +# +# # good +# args.concat(foo) +# args += foo +# hash.merge!(other) +# +# # bad +# self.foo = foo.concat(ary) +# +# # good +# foo.concat(ary) +# self.foo += ary +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:31 +class RuboCop::Cop::Style::RedundantSelfAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:52 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:52 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:52 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:52 + def on_lvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:69 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:96 + def redundant_nonself_assignment?(param0 = T.unsafe(nil), param1, param2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:86 + def redundant_self_assignment?(param0 = T.unsafe(nil), param1); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:112 + def correction_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:81 + def method_returning_self?(method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:105 + def redundant_assignment?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:45 +RuboCop::Cop::Style::RedundantSelfAssignment::ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:38 +RuboCop::Cop::Style::RedundantSelfAssignment::METHODS_RETURNING_SELF = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment.rb:35 +RuboCop::Cop::Style::RedundantSelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# Checks for places where conditional branch makes redundant self-assignment. +# +# It only detects local variable because it may replace state of instance variable, +# class variable, and global variable that have state across methods with `nil`. +# +# @example +# +# # bad +# foo = condition ? bar : foo +# +# # good +# foo = bar if condition +# +# # bad +# foo = condition ? foo : bar +# +# # good +# foo = bar unless condition +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:25 +class RuboCop::Cop::Style::RedundantSelfAssignmentBranch < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:32 + def bad_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:36 + def on_lvasgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:59 + def inconvertible_to_modifier?(if_branch, else_branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:64 + def multiple_statements?(branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:72 + def register_offense(if_node, offense_branch, opposite_branch, keyword); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:68 + def self_assign?(variable, branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:53 + def use_if_and_else_branch?(expression); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_self_assignment_branch.rb:29 +RuboCop::Cop::Style::RedundantSelfAssignmentBranch::MSG = T.let(T.unsafe(nil), String) + +# Identifies instances of sorting and then +# taking only the first or last element. The same behavior can +# be accomplished without a relatively expensive sort by using +# `Enumerable#min` instead of sorting and taking the first +# element and `Enumerable#max` instead of sorting and taking the +# last element. Similarly, `Enumerable#min_by` and +# `Enumerable#max_by` can replace `Enumerable#sort_by` calls +# after which only the first or last element is used. +# +# @example +# # bad +# [2, 1, 3].sort.first +# [2, 1, 3].sort[0] +# [2, 1, 3].sort.at(0) +# [2, 1, 3].sort.slice(0) +# +# # good +# [2, 1, 3].min +# +# # bad +# [2, 1, 3].sort.last +# [2, 1, 3].sort[-1] +# [2, 1, 3].sort.at(-1) +# [2, 1, 3].sort.slice(-1) +# +# # good +# [2, 1, 3].max +# +# # bad +# arr.sort_by(&:foo).first +# arr.sort_by(&:foo)[0] +# arr.sort_by(&:foo).at(0) +# arr.sort_by(&:foo).slice(0) +# +# # good +# arr.min_by(&:foo) +# +# # bad +# arr.sort_by(&:foo).last +# arr.sort_by(&:foo)[-1] +# arr.sort_by(&:foo).at(-1) +# arr.sort_by(&:foo).slice(-1) +# +# # good +# arr.max_by(&:foo) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:79 +class RuboCop::Cop::Style::RedundantSort < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:104 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:88 + def redundant_sort?(param0 = T.unsafe(nil)); end + + private + + # This gets the start of the accessor whether it has a dot + # (e.g. `.first`) or doesn't (e.g. `[0]`) + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:192 + def accessor_start(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:182 + def arg_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:186 + def arg_value(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:147 + def autocorrect(corrector, node, sort_node, sorter, accessor); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:165 + def base(accessor, arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:114 + def find_redundant_sort(*nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:135 + def message(node, sorter, accessor); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:131 + def offense_range(sort_node, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:124 + def register_offense(node, sort_node, sorter, accessor); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:156 + def replace_with_logical_operator(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:173 + def suffix(sorter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:161 + def suggestion(sorter, accessor, arg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:200 + def with_logical_operator?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:83 +RuboCop::Cop::Style::RedundantSort::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort.rb:85 +RuboCop::Cop::Style::RedundantSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Identifies places where `sort_by { ... }` can be replaced by +# `sort`. +# +# @example +# # bad +# array.sort_by { |x| x } +# array.sort_by do |var| +# var +# end +# +# # good +# array.sort +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:18 +class RuboCop::Cop::Style::RedundantSortBy < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:25 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:35 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:48 + def redundant_sort_by_block(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:53 + def redundant_sort_by_numblock(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:57 + def sort_by_range(send, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:22 +RuboCop::Cop::Style::RedundantSortBy::MSG_BLOCK = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/redundant_sort_by.rb:23 +RuboCop::Cop::Style::RedundantSortBy::MSG_NUMBLOCK = T.let(T.unsafe(nil), String) + +# Enforces using // or %r around regular expressions. +# +# @example EnforcedStyle: slashes (default) +# # bad +# snake_case = %r{^[\dA-Z_]+$} +# +# # bad +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# +# # good +# snake_case = /^[\dA-Z_]+$/ +# +# # good +# regex = / +# foo +# (bar) +# (baz) +# /x +# @example EnforcedStyle: percent_r +# # bad +# snake_case = /^[\dA-Z_]+$/ +# +# # bad +# regex = / +# foo +# (bar) +# (baz) +# /x +# +# # good +# snake_case = %r{^[\dA-Z_]+$} +# +# # good +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# @example EnforcedStyle: mixed +# # bad +# snake_case = %r{^[\dA-Z_]+$} +# +# # bad +# regex = / +# foo +# (bar) +# (baz) +# /x +# +# # good +# snake_case = /^[\dA-Z_]+$/ +# +# # good +# regex = %r{ +# foo +# (bar) +# (baz) +# }x +# @example AllowInnerSlashes: false (default) +# # If `false`, the cop will always recommend using `%r` if one or more +# # slashes are found in the regexp string. +# +# # bad +# x =~ /home\// +# +# # good +# x =~ %r{home/} +# @example AllowInnerSlashes: true +# # good +# x =~ /home\// +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:84 +class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:92 + def on_regexp(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:135 + def allow_inner_slashes?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:123 + def allowed_mixed_percent_r?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:113 + def allowed_mixed_slash?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:152 + def allowed_omit_parentheses_with_percent_r_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:117 + def allowed_percent_r_literal?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:109 + def allowed_slash_literal?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:212 + def calculate_replacement(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:127 + def contains_disallowed_slash?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:131 + def contains_slash?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:161 + def correct_delimiters(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:167 + def correct_inner_slashes(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:200 + def inner_slash_after_correction(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:196 + def inner_slash_before_correction(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:204 + def inner_slash_for(opening_delimiter); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:183 + def inner_slash_indices(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:139 + def node_body(node, include_begin_nodes: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:148 + def preferred_delimiters; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:144 + def slash_literal?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:90 +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/regexp_literal.rb:89 +RuboCop::Cop::Style::RegexpLiteral::MSG_USE_SLASHES = T.let(T.unsafe(nil), String) + +# Checks for uses of rescue in its modifier form. +# +# The cop to check `rescue` in its modifier form is added for following +# reasons: +# +# * The syntax of modifier form `rescue` can be misleading because it +# might led us to believe that `rescue` handles the given exception +# but it actually rescue all exceptions to return the given rescue +# block. In this case, value returned by handle_error or +# SomeException. +# +# * Modifier form `rescue` would rescue all the exceptions. It would +# silently skip all exception or errors and handle the error. +# Example: If `NoMethodError` is raised, modifier form rescue would +# handle the exception. +# +# @example +# # bad +# some_method rescue handle_error +# +# # bad +# some_method rescue SomeException +# +# # good +# begin +# some_method +# rescue +# handle_error +# end +# +# # good +# begin +# some_method +# rescue SomeException +# handle_error +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:42 +class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RescueNode + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:54 + def on_resbody(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:72 + def correct_rescue_block(corrector, node, parenthesized); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:88 + def indentation_and_offset(node, parenthesized); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:68 + def parenthesized?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:50 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_modifier.rb:48 +RuboCop::Cop::Style::RescueModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for rescuing `StandardError`. There are two supported +# styles `implicit` and `explicit`. This cop will not register an offense +# if any error other than `StandardError` is specified. +# +# @example EnforcedStyle: explicit (default) +# # `explicit` will enforce using `rescue StandardError` +# # instead of `rescue`. +# +# # bad +# begin +# foo +# rescue +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError +# bar +# end +# +# # good +# begin +# foo +# rescue OtherError +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, SecurityError +# bar +# end +# @example EnforcedStyle: implicit +# # `implicit` will enforce using `rescue` instead of +# # `rescue StandardError`. +# +# # bad +# begin +# foo +# rescue StandardError +# bar +# end +# +# # good +# begin +# foo +# rescue +# bar +# end +# +# # good +# begin +# foo +# rescue OtherError +# bar +# end +# +# # good +# begin +# foo +# rescue StandardError, SecurityError +# bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:73 +class RuboCop::Cop::Style::RescueStandardError < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:92 + def on_resbody(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:88 + def rescue_standard_error?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:83 + def rescue_without_error_class?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:118 + def offense_for_explicit_enforced_style(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:107 + def offense_for_implicit_enforced_style(node, error); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:80 +RuboCop::Cop::Style::RescueStandardError::MSG_EXPLICIT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/rescue_standard_error.rb:79 +RuboCop::Cop::Style::RescueStandardError::MSG_IMPLICIT = T.let(T.unsafe(nil), String) + +# Enforces consistency between 'return nil' and 'return'. +# +# Supported styles are: return, return_nil. +# +# @example EnforcedStyle: return (default) +# # bad +# def foo(arg) +# return nil if arg +# end +# +# # good +# def foo(arg) +# return if arg +# end +# @example EnforcedStyle: return_nil +# # bad +# def foo(arg) +# return if arg +# end +# +# # good +# def foo(arg) +# return nil if arg +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:31 +class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:86 + def chained_send?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:89 + def define_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:44 + def on_return(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:42 + def return_nil_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:39 + def return_node?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:76 + def correct_style?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:72 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:81 + def scoped_node?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:35 +RuboCop::Cop::Style::ReturnNil::RETURN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/return_nil.rb:36 +RuboCop::Cop::Style::ReturnNil::RETURN_NIL_MSG = T.let(T.unsafe(nil), String) + +# Transforms usages of a method call safeguarded by a non `nil` +# check for the variable whose method is being called to +# safe navigation (`&.`). If there is a method chain, all of the methods +# in the chain need to be checked for safety, and all of the methods will +# need to be changed to use safe navigation. +# +# The default for `ConvertCodeThatCanStartToReturnNil` is `false`. +# When configured to `true`, this will +# check for code in the format `!foo.nil? && foo.bar`. As it is written, +# the return of this code is limited to `false` and whatever the return +# of the method is. If this is converted to safe navigation, +# `foo&.bar` can start returning `nil` as well as what the method +# returns. +# +# The default for `MaxChainLength` is `2` +# We have limited the cop to not register an offense for method chains +# that exceed this option is set. +# +# @example +# # bad +# foo.bar if foo +# foo.bar.baz if foo +# foo.bar(param1, param2) if foo +# foo.bar { |e| e.something } if foo +# foo.bar(param) { |e| e.something } if foo +# +# foo.bar if !foo.nil? +# foo.bar unless !foo +# foo.bar unless foo.nil? +# +# foo && foo.bar +# foo && foo.bar.baz +# foo && foo.bar(param1, param2) +# foo && foo.bar { |e| e.something } +# foo && foo.bar(param) { |e| e.something } +# +# # good +# foo&.bar +# foo&.bar&.baz +# foo&.bar(param1, param2) +# foo&.bar { |e| e.something } +# foo&.bar(param) { |e| e.something } +# foo && foo.bar.baz.qux # method chain with more than 2 methods +# foo && foo.nil? # method that `nil` responds to +# +# # Method calls that do not use `.` +# foo && foo < bar +# foo < bar if foo +# +# # When checking `foo&.empty?` in a conditional, `foo` being `nil` will actually +# # do the opposite of what the author intends. +# foo && foo.empty? +# +# # This could start returning `nil` as well as the return of the method +# foo.nil? || foo.bar +# !foo || foo.bar +# +# # Methods that are used on assignment, arithmetic operation or +# # comparison should not be converted to use safe navigation +# foo.baz = bar if foo +# foo.baz + bar if foo +# foo.bar > 2 if foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:79 +class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::NilMethods + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:121 + def check_node(node); end + + # if format: (if checked_variable body nil) + # unless format: (if checked_variable nil body) + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:94 + def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:109 + def not_nil_check?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:117 + def on_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:111 + def on_if(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:132 + def use_var_only_in_unless_modifier?(node, variable); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:278 + def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:176 + def allowed_if_condition?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:138 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:270 + def begin_range(node, method_call); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:232 + def chain_length(method_chain, method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:157 + def comments(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:274 + def end_range(node, method_call); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:214 + def extract_common_parts(method_chain, checked_variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:185 + def extract_parts(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:204 + def extract_parts_from_and(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:194 + def extract_parts_from_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:222 + def find_matching_receiver_invocation(method_chain, checked_variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:150 + def handle_comments(corrector, node, method_call); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:291 + def max_chain_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:180 + def method_call(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:266 + def method_called?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:258 + def negated?(send_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:163 + def relevant_comment_ranges(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:252 + def unsafe_method?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:240 + def unsafe_method_used?(method_chain, method); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:87 +RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/safe_navigation.rb:85 +RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String) + +# Identifies usages of `shuffle.first`, +# `shuffle.last`, and `shuffle[]` and change them to use +# `sample` instead. +# +# @example +# # bad +# [1, 2, 3].shuffle.first +# [1, 2, 3].shuffle.first(2) +# [1, 2, 3].shuffle.last +# [2, 1, 3].shuffle.at(0) +# [2, 1, 3].shuffle.slice(0) +# [1, 2, 3].shuffle[2] +# [1, 2, 3].shuffle[0, 2] # sample(2) will do the same +# [1, 2, 3].shuffle[0..2] # sample(3) will do the same +# [1, 2, 3].shuffle(random: Random.new).first +# +# # good +# [1, 2, 3].shuffle +# [1, 2, 3].sample +# [1, 2, 3].sample(3) +# [1, 2, 3].shuffle[1, 3] # sample(3) might return a longer Array +# [1, 2, 3].shuffle[1..3] # sample(3) might return a longer Array +# [1, 2, 3].shuffle[foo, bar] +# [1, 2, 3].shuffle(random: Random.new) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:30 +class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:41 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:37 + def sample_candidate?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:123 + def correction(shuffle_arg, method, method_args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:139 + def extract_source(args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:117 + def message(shuffle_arg, method, method_args, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:58 + def offensive?(method, method_args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:95 + def range_size(range_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:130 + def sample_arg(method, method_args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:69 + def sample_size(method_args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:78 + def sample_size_for_one_arg(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:88 + def sample_size_for_two_args(first, second); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:111 + def source_range(shuffle_node, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:33 +RuboCop::Cop::Style::Sample::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/sample.rb:34 +RuboCop::Cop::Style::Sample::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Looks for places where an subset of an Enumerable (array, +# range, set, etc.; see note below) is calculated based on a `Regexp` +# match, and suggests `grep` or `grep_v` instead. +# +# NOTE: Hashes do not behave as you may expect with `grep`, which +# means that `hash.grep` is not equivalent to `hash.select`. Although +# RuboCop is limited by static analysis, this cop attempts to avoid +# registering an offense when the receiver is a hash (hash literal, +# `Hash.new`, `Hash#[]`, or `to_h`/`to_hash`). +# +# NOTE: `grep` and `grep_v` were optimized when used without a block +# in Ruby 3.0, but may be slower in previous versions. +# See https://bugs.ruby-lang.org/issues/17030 +# +# @example +# # bad (select or find_all) +# array.select { |x| x.match? /regexp/ } +# array.select { |x| /regexp/.match?(x) } +# array.select { |x| x =~ /regexp/ } +# array.select { |x| /regexp/ =~ x } +# +# # bad (reject) +# array.reject { |x| x.match? /regexp/ } +# array.reject { |x| /regexp/.match?(x) } +# array.reject { |x| x =~ /regexp/ } +# array.reject { |x| /regexp/ =~ x } +# +# # good +# array.grep(regexp) +# array.grep_v(regexp) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:45 +class RuboCop::Cop::Style::SelectByRegexp < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:78 + def calls_lvar?(param0 = T.unsafe(nil), param1); end + + # Returns true if a node appears to return a hash + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:64 + def creates_hash?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:73 + def env_const?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:86 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:55 + def regexp_match?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:118 + def extract_send_node(block_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:127 + def find_regexp(node, block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:138 + def match_predicate_without_receiver?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:99 + def receiver_allowed?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:105 + def register_offense(node, block_node, regexp); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:49 +RuboCop::Cop::Style::SelectByRegexp::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:52 +RuboCop::Cop::Style::SelectByRegexp::REGEXP_METHODS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:51 +RuboCop::Cop::Style::SelectByRegexp::REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/select_by_regexp.rb:50 +RuboCop::Cop::Style::SelectByRegexp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Enforces the use the shorthand for self-assignment. +# +# @example +# +# # bad +# x = x + 1 +# +# # good +# x += 1 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:15 +class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:33 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:29 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:25 + def on_lvasgn(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:94 + def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:74 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:89 + def autocorrect_boolean_node(corrector, node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:84 + def autocorrect_send_node(corrector, node, rhs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:39 + def check(node, var_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:62 + def check_boolean_node(node, rhs, var_name, var_type); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:50 + def check_send_node(node, rhs, var_name, var_type); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:21 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:18 +RuboCop::Cop::Style::SelfAssignment::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/self_assignment.rb:19 +RuboCop::Cop::Style::SelfAssignment::OPS = T.let(T.unsafe(nil), Array) + +# Checks for multiple expressions placed on the same line. +# It also checks for lines terminated with a semicolon. +# +# This cop has `AllowAsExpressionSeparator` configuration option. +# It allows `;` to separate several expressions on the same line. +# +# @example +# # bad +# foo = 1; bar = 2; +# baz = 3; +# +# # good +# foo = 1 +# bar = 2 +# baz = 3 +# @example AllowAsExpressionSeparator: false (default) +# # bad +# foo = 1; bar = 2 +# @example AllowAsExpressionSeparator: true +# # good +# foo = 1; bar = 2 +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:29 +class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:45 + def on_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:39 + def on_new_investigation; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:63 + def check_for_line_terminator_or_opener; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:72 + def each_semicolon; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:103 + def expressions_per_line(exprs); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:117 + def find_range_node(token_before_semicolon); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:109 + def find_semicolon_positions(line); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:123 + def range_nodes; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:83 + def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:79 + def tokens_for_lines; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:35 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/semicolon.rb:33 +RuboCop::Cop::Style::Semicolon::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of the send method. +# +# @example +# # bad +# Foo.send(:bar) +# quuz.send(:fred) +# +# # good +# Foo.__send__(:bar) +# quuz.public_send(:fred) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/send.rb:16 +class RuboCop::Cop::Style::Send < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/send.rb:20 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/send.rb:20 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/send.rb:17 +RuboCop::Cop::Style::Send::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/send.rb:18 +RuboCop::Cop::Style::Send::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `fail` and `raise`. +# +# @example EnforcedStyle: only_raise (default) +# # The `only_raise` style enforces the sole use of `raise`. +# # bad +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# # handle it +# end +# +# Kernel.fail +# +# # good +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# raise +# rescue Exception +# # handle it +# end +# +# Kernel.raise +# @example EnforcedStyle: only_fail +# # The `only_fail` style enforces the sole use of `fail`. +# # bad +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# raise +# rescue Exception +# # handle it +# end +# +# Kernel.raise +# +# # good +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# # handle it +# end +# +# Kernel.fail +# @example EnforcedStyle: semantic +# # The `semantic` style enforces the use of `fail` to signal an +# # exception, then will use `raise` to trigger an offense after +# # it has been rescued. +# # bad +# begin +# raise +# rescue Exception +# # handle it +# end +# +# def watch_out +# # Error thrown +# rescue Exception +# fail +# end +# +# Kernel.fail +# Kernel.raise +# +# # good +# begin +# fail +# rescue Exception +# # handle it +# end +# +# def watch_out +# fail +# rescue Exception +# raise 'Preferably with descriptive message' +# end +# +# explicit_receiver.fail +# explicit_receiver.raise +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:107 +class RuboCop::Cop::Style::SignalException < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:120 + def custom_fail_methods(param0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:117 + def kernel_call?(param0 = T.unsafe(nil), param1); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:122 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:127 + def on_rescue(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:139 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:204 + def allow(method_name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:186 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:165 + def check_scope(method_name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:178 + def check_send(method_name, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:198 + def command_or_kernel_call?(name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:208 + def each_command_or_kernel_call(method_name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:154 + def message(method_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:111 +RuboCop::Cop::Style::SignalException::FAIL_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:112 +RuboCop::Cop::Style::SignalException::RAISE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/signal_exception.rb:114 +RuboCop::Cop::Style::SignalException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Sometimes using dig method ends up with just a single +# argument. In such cases, dig should be replaced with []. +# +# @example +# # bad +# { key: 'value' }.dig(:key) +# [1, 2, 3].dig(0) +# +# # good +# { key: 'value' }[:key] +# [1, 2, 3][0] +# +# # good +# { key1: { key2: 'value' } }.dig(:key1, :key2) +# [1, [2, [3]]].dig(1, 1) +# +# # good +# keys = %i[key1 key2] +# { key1: { key2: 'value' } }.dig(*keys) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_argument_dig.rb:31 +class RuboCop::Cop::Style::SingleArgumentDig < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_argument_dig.rb:42 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_argument_dig.rb:38 + def single_argument_dig?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_argument_dig.rb:34 +RuboCop::Cop::Style::SingleArgumentDig::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_argument_dig.rb:35 +RuboCop::Cop::Style::SingleArgumentDig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks whether the block parameters of a single-line +# method accepting a block match the names specified via configuration. +# +# For instance one can configure `reduce`(`inject`) to use |a, e| as +# parameters. +# +# Configuration option: Methods +# Should be set to use this cop. Array of hashes, where each key is the +# method name and value - array of argument names. +# +# @example Methods: [{reduce: %w[a b]}] +# # bad +# foo.reduce { |c, d| c + d } +# foo.reduce { |_, _d| 1 } +# +# # good +# foo.reduce { |a, b| a + b } +# foo.reduce { |a, _b| a } +# foo.reduce { |a, (id, _)| a + id } +# foo.reduce { true } +# +# # good +# foo.reduce do |c, d| +# c + d +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:31 +class RuboCop::Cop::Style::SingleLineBlockParams < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:36 + def on_block(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:105 + def args_match?(method_name, args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:69 + def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:57 + def build_preferred_arguments_map(node, preferred_arguments); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:79 + def eligible_arguments?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:83 + def eligible_method?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:95 + def method_name(method); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:91 + def method_names; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:87 + def methods; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:99 + def target_args(method_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_block_params.rb:34 +RuboCop::Cop::Style::SingleLineBlockParams::MSG = T.let(T.unsafe(nil), String) + +# Checks for single-line method definitions that contain a body. +# It will accept single-line methods with no body. +# +# Endless methods added in Ruby 3.0 are also accepted by this cop. +# +# If `Style/EndlessMethod` is enabled with `EnforcedStyle: allow_single_line` or +# `allow_always`, single-line methods will be autocorrected to endless +# methods if there is only one statement in the body. +# +# @example +# # bad +# def some_method; body end +# def link_to(url); {:name => url}; end +# def @table.columns; super; end +# +# # good +# def self.resource_class=(klass); end +# def @table.columns; end +# def some_method() = body +# @example AllowIfMethodIsEmpty: true (default) +# # good +# def no_op; end +# @example AllowIfMethodIsEmpty: false +# # bad +# def no_op; end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:34 +class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:41 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:41 + def on_defs(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:60 + def allow_empty?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:52 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:97 + def break_line_before(corrector, node, range, indent_steps: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:88 + def correct_to_endless(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:64 + def correct_to_endless?(body_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:74 + def correct_to_multiline(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:136 + def disallow_endless_method_style?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:104 + def each_part(body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:121 + def method_body_source(method_body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:114 + def move_comment(node, corrector); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:132 + def require_parentheses?(method_body); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:38 +RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/single_line_methods.rb:39 +RuboCop::Cop::Style::SingleLineMethods::NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = T.let(T.unsafe(nil), Array) + +# Checks that arrays are sliced with endless ranges instead of +# `ary[start..-1]` on Ruby 2.6+. +# +# @example +# # bad +# items[1..-1] +# +# # good +# items[1..] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/slicing_with_range.rb:28 +class RuboCop::Cop::Style::SlicingWithRange < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/slicing_with_range.rb:40 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/slicing_with_range.rb:38 + def range_till_minus_one?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/slicing_with_range.rb:34 +RuboCop::Cop::Style::SlicingWithRange::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/slicing_with_range.rb:35 +RuboCop::Cop::Style::SlicingWithRange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# If the branch of a conditional consists solely of a conditional node, +# its conditions can be combined with the conditions of the outer branch. +# This helps to keep the nesting level from getting too deep. +# +# @example +# # bad +# if condition_a +# if condition_b +# do_something +# end +# end +# +# # bad +# if condition_b +# do_something +# end if condition_a +# +# # good +# if condition_a && condition_b +# do_something +# end +# @example AllowModifier: false (default) +# # bad +# if condition_a +# do_something if condition_b +# end +# +# # bad +# if condition_b +# do_something +# end if condition_a +# @example AllowModifier: true +# # good +# if condition_a +# do_something if condition_b +# end +# +# # good +# if condition_b +# do_something +# end if condition_a +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:49 +class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:59 + def on_if(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:238 + def allow_modifier?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:223 + def arguments_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:81 + def assigned_variables(condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:98 + def autocorrect(corrector, node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:110 + def autocorrect_outer_condition_basic(corrector, node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:125 + def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:145 + def correct_for_basic_condition_style(corrector, node, if_branch, and_operator); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:175 + def correct_for_comment(corrector, node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:136 + def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:165 + def correct_for_outer_condition_modify_form_style(corrector, node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:130 + def correct_from_unless_to_if(corrector, node, is_modify_form: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:182 + def correct_outer_condition(corrector, condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:193 + def insert_bang(corrector, node, is_modify_form); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:206 + def insert_bang_for_and(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:89 + def offending_branch?(node, branch); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:242 + def outer_condition_modify_form?(node, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:234 + def replace_condition(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:218 + def require_parentheses?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:74 + def use_variable_assignment_in_condition?(condition, if_branch); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:155 + def wrap_condition(corrector, condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:229 + def wrap_condition?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:55 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/sole_nested_conditional.rb:53 +RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) + +# This cop looks for uses of Perl-style global variables. +# Correcting to global variables in the 'English' library +# will add a require statement to the top of the file if +# enabled by RequireEnglish config. +# +# Like `use_perl_names` but allows builtin global vars. +# +# # good +# puts $LOAD_PATH +# puts $LOADED_FEATURES +# puts $PROGRAM_NAME +# puts ARGV +# puts $: +# puts $" +# puts $0 +# puts $! +# puts $@ +# puts $; +# puts $, +# puts $/ +# puts $\ +# puts $. +# puts $_ +# puts $> +# puts $< +# puts $$ +# puts $? +# puts $~ +# puts $= +# puts $* +# +# @example EnforcedStyle: use_english_names (default) +# # good +# require 'English' # or this could be in another file. +# +# puts $LOAD_PATH +# puts $LOADED_FEATURES +# puts $PROGRAM_NAME +# puts $ERROR_INFO +# puts $ERROR_POSITION +# puts $FIELD_SEPARATOR # or $FS +# puts $OUTPUT_FIELD_SEPARATOR # or $OFS +# puts $INPUT_RECORD_SEPARATOR # or $RS +# puts $OUTPUT_RECORD_SEPARATOR # or $ORS +# puts $INPUT_LINE_NUMBER # or $NR +# puts $LAST_READ_LINE +# puts $DEFAULT_OUTPUT +# puts $DEFAULT_INPUT +# puts $PROCESS_ID # or $PID +# puts $CHILD_STATUS +# puts $LAST_MATCH_INFO +# puts $IGNORECASE +# puts $ARGV # or ARGV +# @example EnforcedStyle: use_perl_names +# # good +# puts $: +# puts $" +# puts $0 +# puts $! +# puts $@ +# puts $; +# puts $, +# puts $/ +# puts $\ +# puts $. +# puts $_ +# puts $> +# puts $< +# puts $$ +# puts $? +# puts $~ +# puts $= +# puts $* +# @example EnforcedStyle: use_builtin_english_names +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:88 +class RuboCop::Cop::Style::SpecialGlobalVars < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RequireLibrary + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:177 + def autocorrect(corrector, node, global_var); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:169 + def message(global_var); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:153 + def on_gvar(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:148 + def on_new_investigation; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:248 + def add_require_english?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:242 + def english_name_replacement(preferred_name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:191 + def format_english_message(global_var); end + + # For now, we assume that lists are 2 items or less. Easy grammar! + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:213 + def format_list(items); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:199 + def format_message(english, regular, global); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:236 + def matching_styles(global); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:228 + def preferred_names(global); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:217 + def replacement(node, global_var); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:252 + def should_require_english?(global_var); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:129 +RuboCop::Cop::Style::SpecialGlobalVars::BUILTIN_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:101 +RuboCop::Cop::Style::SpecialGlobalVars::ENGLISH_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:146 +RuboCop::Cop::Style::SpecialGlobalVars::LIBRARY_NAME = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:94 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_BOTH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:97 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_ENGLISH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:99 +RuboCop::Cop::Style::SpecialGlobalVars::MSG_REGULAR = T.let(T.unsafe(nil), String) + +# Anything *not* in this set is provided by the English library. +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:123 +RuboCop::Cop::Style::SpecialGlobalVars::NON_ENGLISH_VARS = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:125 +RuboCop::Cop::Style::SpecialGlobalVars::PERL_VARS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/special_global_vars.rb:140 +RuboCop::Cop::Style::SpecialGlobalVars::STYLE_VARS_MAP = T.let(T.unsafe(nil), Hash) + +# Check for parentheses around stabby lambda arguments. +# There are two different styles. Defaults to `require_parentheses`. +# +# @example EnforcedStyle: require_parentheses (default) +# # bad +# ->a,b,c { a + b + c } +# +# # good +# ->(a,b,c) { a + b + c} +# @example EnforcedStyle: require_no_parentheses +# # bad +# ->(a,b,c) { a + b + c } +# +# # good +# ->a,b,c { a + b + c} +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:22 +class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:28 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:54 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:46 + def missing_parentheses?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:58 + def missing_parentheses_corrector(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:73 + def parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:50 + def redundant_parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:69 + def stabby_lambda_with_args?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:62 + def unwanted_parentheses_corrector(corrector, node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:27 +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_NO_REQUIRE = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/stabby_lambda_parentheses.rb:26 +RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), String) + +# Checks for places where classes with only class methods can be +# replaced with a module. Classes should be used only when it makes sense to create +# instances out of them. +# +# @example +# # bad +# class SomeClass +# def self.some_method +# # body omitted +# end +# +# def self.some_other_method +# # body omitted +# end +# end +# +# # good +# module SomeModule +# module_function +# +# def some_method +# # body omitted +# end +# +# def some_other_method +# # body omitted +# end +# end +# +# # good - has instance method +# class SomeClass +# def instance_method; end +# def self.class_method; end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:46 +class RuboCop::Cop::Style::StaticClass < ::RuboCop::Cop::Base + include ::RuboCop::Cop::VisibilityHelp + + # source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:51 + def on_class(class_node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:59 + def class_convertible_to_module?(class_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:83 + def class_elements(class_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:71 + def extend_call?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:75 + def sclass_convertible_to_module?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/static_class.rb:49 +RuboCop::Cop::Style::StaticClass::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `$stderr.puts` can be replaced by +# `warn`. The latter has the advantage of easily being disabled by, +# the `-W0` interpreter flag or setting `$VERBOSE` to `nil`. +# +# @example +# # bad +# $stderr.puts('hello') +# +# # good +# warn('hello') +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:17 +class RuboCop::Cop::Style::StderrPuts < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:32 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:25 + def stderr_puts?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:43 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:47 + def stderr_gvar?(sym); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:51 + def stderr_puts_range(send); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:21 +RuboCop::Cop::Style::StderrPuts::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/stderr_puts.rb:22 +RuboCop::Cop::Style::StderrPuts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for uses of `String#split` with empty string or regexp literal argument. +# +# @example +# # bad +# string.split(//) +# string.split('') +# +# # good +# string.chars +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_chars.rb:21 +class RuboCop::Cop::Style::StringChars < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_chars.rb:29 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_chars.rb:27 +RuboCop::Cop::Style::StringChars::BAD_ARGUMENTS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_chars.rb:25 +RuboCop::Cop::Style::StringChars::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_chars.rb:26 +RuboCop::Cop::Style::StringChars::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for places where string concatenation +# can be replaced with string interpolation. +# +# The cop can autocorrect simple cases but will skip autocorrecting +# more complex cases where the resulting code would be harder to read. +# In those cases, it might be useful to extract statements to local +# variables or methods which you can then interpolate in a string. +# +# NOTE: When concatenation between two strings is broken over multiple +# lines, this cop does not register an offense; instead, +# `Style/LineEndConcatenation` will pick up the offense if enabled. +# +# Two modes are supported: +# 1. `aggressive` style checks and corrects all occurrences of `+` where +# either the left or right side of `+` is a string literal. +# 2. `conservative` style on the other hand, checks and corrects only if +# left side (receiver of `+` method call) is a string literal. +# This is useful when the receiver is some expression that returns string like `Pathname` +# instead of a string literal. +# +# @example Mode: aggressive (default) +# # bad +# email_with_name = user.name + ' <' + user.email + '>' +# Pathname.new('/') + 'test' +# +# # good +# email_with_name = "#{user.name} <#{user.email}>" +# email_with_name = format('%s <%s>', user.name, user.email) +# "#{Pathname.new('/')}test" +# +# # accepted, line-end concatenation +# name = 'First' + +# 'Last' +# @example Mode: conservative +# # bad +# 'Hello' + user.name +# +# # good +# "Hello #{user.name}" +# user.name + '!!' +# Pathname.new('/') + 'test' +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:53 +class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:69 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:73 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:62 + def string_concatenation?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:116 + def collect_parts(node, parts = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:141 + def corrected_ancestor?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:108 + def find_topmost_plus_node(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:162 + def handle_quotes(parts); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:135 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:98 + def line_end_concatenation?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:172 + def mode; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:127 + def plus_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:86 + def register_offense(topmost_plus_node, parts); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:145 + def replacement(parts); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:168 + def single_quoted?(str_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:131 + def uncorrectable?(part); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:58 +RuboCop::Cop::Style::StringConcatenation::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_concatenation.rb:59 +RuboCop::Cop::Style::StringConcatenation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for the use of strings as keys in hashes. The use of +# symbols is preferred instead. +# +# @example +# # bad +# { 'one' => 1, 'two' => 2, 'three' => 3 } +# +# # good +# { one: 1, two: 2, three: 3 } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_hash_keys.rb:19 +class RuboCop::Cop::Style::StringHashKeys < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_hash_keys.rb:42 + def on_pair(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_hash_keys.rb:30 + def receive_environments_method?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_hash_keys.rb:25 + def string_hash_key?(param0 = T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_hash_keys.rb:22 +RuboCop::Cop::Style::StringHashKeys::MSG = T.let(T.unsafe(nil), String) + +# Checks if uses of quotes match the configured preference. +# +# @example EnforcedStyle: single_quotes (default) +# # bad +# "No special symbols" +# "No string interpolation" +# "Just text" +# +# # good +# 'No special symbols' +# 'No string interpolation' +# 'Just text' +# "Wait! What's #{this}!" +# @example EnforcedStyle: double_quotes +# # bad +# 'Just some text' +# 'No special chars or interpolation' +# +# # good +# "Just some text" +# "No special chars or interpolation" +# "Every string in #{project} uses double_quotes" +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:29 +class RuboCop::Cop::Style::StringLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:37 + def on_dstr(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:127 + def accept_child_double_quotes?(nodes); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:71 + def all_string_literals?(nodes); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:61 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:109 + def check_multiline_quote_style(node, quote); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:105 + def consistent_multiline?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:75 + def detect_quote_styles(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:87 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:97 + def offense?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:65 + def register_offense(node, message: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:123 + def unexpected_double_quotes?(quote); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:119 + def unexpected_single_quotes?(quote); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals.rb:35 +RuboCop::Cop::Style::StringLiterals::MSG_INCONSISTENT = T.let(T.unsafe(nil), String) + +# Checks that quotes inside the string interpolation +# match the configured preference. +# +# @example EnforcedStyle: single_quotes (default) +# # bad +# result = "Tests #{success ? "PASS" : "FAIL"}" +# +# # good +# result = "Tests #{success ? 'PASS' : 'FAIL'}" +# @example EnforcedStyle: double_quotes +# # bad +# result = "Tests #{success ? 'PASS' : 'FAIL'}" +# +# # good +# result = "Tests #{success ? "PASS" : "FAIL"}" +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals_in_interpolation.rb:22 +class RuboCop::Cop::Style::StringLiteralsInInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals_in_interpolation.rb:28 + def autocorrect(corrector, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals_in_interpolation.rb:34 + def message(_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_literals_in_interpolation.rb:41 + def offense?(node); end +end + +# Enforces the use of consistent method names +# from the String class. +# +# @example +# # bad +# 'name'.intern +# 'var'.unfavored_method +# +# # good +# 'name'.to_sym +# 'var'.preferred_method +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_methods.rb:17 +class RuboCop::Cop::Style::StringMethods < ::RuboCop::Cop::Base + include ::RuboCop::Cop::MethodPreference + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_methods.rb:23 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/string_methods.rb:23 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/string_methods.rb:21 +RuboCop::Cop::Style::StringMethods::MSG = T.let(T.unsafe(nil), String) + +# Identifies places where `lstrip.rstrip` can be replaced by +# `strip`. +# +# @example +# # bad +# 'abc'.lstrip.rstrip +# 'abc'.rstrip.lstrip +# +# # good +# 'abc'.strip +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/strip.rb:16 +class RuboCop::Cop::Style::Strip < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/strip.rb:24 + def lstrip_rstrip(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/strip.rb:29 + def on_send(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/strip.rb:20 +RuboCop::Cop::Style::Strip::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/strip.rb:21 +RuboCop::Cop::Style::Strip::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for inheritance from Struct.new. +# +# @example +# # bad +# class Person < Struct.new(:first_name, :last_name) +# def age +# 42 +# end +# end +# +# # good +# Person = Struct.new(:first_name, :last_name) do +# def age +# 42 +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:26 +class RuboCop::Cop::Style::StructInheritance < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:33 + def on_class(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:45 + def struct_constructor?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:52 + def correct_parent(parent, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:62 + def range_for_empty_class_body(class_node, struct_new); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/struct_inheritance.rb:30 +RuboCop::Cop::Style::StructInheritance::MSG = T.let(T.unsafe(nil), String) + +# Enforces the use of shorthand-style swapping of 2 variables. +# +# @example +# # bad +# tmp = x +# x = y +# y = tmp +# +# # good +# x, y = y, x +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:21 +class RuboCop::Cop::Style::SwapValues < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_asgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_casgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_cvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_gvasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_ivasgn(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:30 + def on_lvasgn(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:47 + def allowed_assignment?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:104 + def correction_range(tmp_assign, y_assign); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:81 + def lhs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:66 + def message(x_assign, y_assign); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:75 + def replacement(x_assign); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:95 + def rhs(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:60 + def simple_assignment?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:51 + def swapping_values?(tmp_assign, x_assign, y_assign); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:25 +RuboCop::Cop::Style::SwapValues::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/swap_values.rb:28 +RuboCop::Cop::Style::SwapValues::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Set) + +# Checks for array literals made up of symbols that are not +# using the %i() syntax. +# +# Alternatively, it checks for symbol arrays using the %i() syntax on +# projects which do not want to use that syntax, perhaps because they +# support a version of Ruby lower than 2.0. +# +# Configuration option: MinSize +# If set, arrays with fewer elements than this value will not trigger the +# cop. For example, a `MinSize` of `3` will not enforce a style on an +# array of 2 or fewer elements. +# +# @example EnforcedStyle: percent (default) +# # good +# %i[foo bar baz] +# +# # bad +# [:foo, :bar, :baz] +# @example EnforcedStyle: brackets +# # good +# [:foo, :bar, :baz] +# +# # bad +# %i[foo bar baz] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:31 +class RuboCop::Cop::Style::SymbolArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:48 + def on_array(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:67 + def build_bracketed_array(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:88 + def symbol_without_quote?(string); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:60 + def symbols_contain_spaces?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:80 + def to_symbol_literal(string); end + + class << self + # Returns the value of attribute largest_brackets. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:45 + def largest_brackets; end + + # Sets the attribute largest_brackets + # + # @param value the value to set the attribute largest_brackets to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:45 + def largest_brackets=(_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:42 +RuboCop::Cop::Style::SymbolArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_array.rb:41 +RuboCop::Cop::Style::SymbolArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +# Checks symbol literal syntax. +# +# @example +# +# # bad +# :"symbol" +# +# # good +# :symbol +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_literal.rb:15 +class RuboCop::Cop::Style::SymbolLiteral < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_literal.rb:20 + def on_sym(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_literal.rb:18 +RuboCop::Cop::Style::SymbolLiteral::MSG = T.let(T.unsafe(nil), String) + +# Use symbols as procs when possible. +# +# If you prefer a style that allows block for method with arguments, +# please set `true` to `AllowMethodsWithArguments`. +# respond_to , and `define_method?` methods are allowed by default. +# These are customizable with `AllowedMethods` option. +# +# @example AllowedPatterns: [/map/] (default) +# # good +# something.map { |s| s.upcase } +# @example AllowMethodsWithArguments: false (default) +# # bad +# something.do_something(foo) { |o| o.bar } +# +# # good +# something.do_something(foo, &:bar) +# @example AllowMethodsWithArguments: true +# # good +# something.do_something(foo) { |o| o.bar } +# @example AllowComments: false (default) +# # bad +# something.do_something do |s| # some comment +# # some comment +# s.upcase # some comment +# # some comment +# end +# @example AllowComments: true +# # good - if there are comment in either position +# something.do_something do |s| # some comment +# # some comment +# s.upcase # some comment +# # some comment +# end +# @example AllowedMethods: [respond_to, define_method] (default) +# # good +# respond_to { |foo| foo.bar } +# define_method(:foo) { |foo| foo.bar } +# @example AllowedPatterns: [] (default) +# # bad +# something.map { |s| s.upcase } +# @example +# # bad +# something.map { |s| s.upcase } +# something.map { _1.upcase } +# +# # good +# something.map(&:upcase) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:88 +class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CommentsHelp + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::AllowedMethods + include ::RuboCop::Cop::AllowedPattern + extend ::RuboCop::Cop::AutoCorrector + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:137 + def destructuring_block_argument?(argument_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:117 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:117 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:99 + def proc_node?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:105 + def symbol_proc?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:102 + def symbol_proc_receiver?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:205 + def allow_comments?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:201 + def allow_if_method_has_argument?(send_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:152 + def allowed_method_name?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:165 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:177 + def autocorrect_with_args(corrector, node, args, method_name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:173 + def autocorrect_without_args(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:191 + def begin_pos_for_replacement(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:186 + def block_range_with_space(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:156 + def register_offense(node, method_name, block_method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:148 + def unsafe_array_usage?(node); end + + # See: https://github.com/rubocop/rubocop/issues/10864 + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:144 + def unsafe_hash_usage?(node); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:112 + def autocorrect_incompatible_with; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:95 +RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/symbol_proc.rb:96 +RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array) + +# Corrector to correct conditional assignment in ternary conditions. +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:504 +class RuboCop::Cop::Style::TernaryCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:509 + def correct(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:513 + def move_assignment_inside_condition(corrector, node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:527 + def correction(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:540 + def element_assignment?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:544 + def extract_branches(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:557 + def move_branch_inside_condition(corrector, branch, assignment); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:552 + def remove_parentheses(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/conditional_assignment.rb:531 + def ternary(node); end + end +end + +# Checks for the presence of parentheses around ternary +# conditions. It is configurable to enforce inclusion or omission of +# parentheses using `EnforcedStyle`. Omission is only enforced when +# removing the parentheses won't cause a different behavior. +# +# `AllowSafeAssignment` option for safe assignment. +# By safe assignment we mean putting parentheses around +# an assignment to indicate "I know I'm using an assignment +# as a condition. It's not a mistake." +# +# @example EnforcedStyle: require_no_parentheses (default) +# # bad +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = (bar && baz) ? a : b +# +# # good +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = bar && baz ? a : b +# @example EnforcedStyle: require_parentheses +# # bad +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = bar && baz ? a : b +# +# # good +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = (bar && baz) ? a : b +# @example EnforcedStyle: require_parentheses_when_complex +# # bad +# foo = (bar?) ? a : b +# foo = (bar.baz?) ? a : b +# foo = bar && baz ? a : b +# +# # good +# foo = bar? ? a : b +# foo = bar.baz? ? a : b +# foo = (bar && baz) ? a : b +# @example AllowSafeAssignment: true (default) +# # good +# foo = (bar = baz) ? a : b +# @example AllowSafeAssignment: false +# # bad +# foo = (bar = baz) ? a : b +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:57 +class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:193 + def method_name(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:69 + def on_if(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:100 + def autocorrect(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:183 + def below_ternary_precedence?(child); end + + # If the condition is parenthesized we recurse and check for any + # complex expressions within it. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:131 + def complex_condition?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:89 + def condition_as_parenthesized_one_line_pattern_matching?(condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:198 + def correct_parenthesized(corrector, condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:208 + def correct_unparenthesized(corrector, condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:151 + def message(node); end + + # Anything that is not a variable, constant, or method/.method call + # will be counted as a complex expression. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:141 + def non_complex_expression?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:145 + def non_complex_send?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:113 + def offense?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:85 + def only_closing_parenthesis_is_last_line?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:169 + def parenthesized?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:161 + def require_parentheses?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:165 + def require_parentheses_when_complex?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:179 + def unparenthesized_method_call?(child); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:173 + def unsafe_autocorrect?(condition); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:212 + def whitespace_after?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:66 +RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:67 +RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:64 +RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/ternary_parentheses.rb:63 +RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set) + +# Newcomers to ruby applications may write top-level methods, +# when ideally they should be organized in appropriate classes or modules. +# This cop looks for definitions of top-level methods and warns about them. +# +# However for ruby scripts it is perfectly fine to use top-level methods. +# Hence this cop is disabled by default. +# +# @example +# # bad +# def some_method +# end +# +# # bad +# def self.some_method +# end +# +# # bad +# define_method(:foo) { puts 1 } +# +# # good +# module Foo +# def some_method +# end +# end +# +# # good +# class Foo +# def self.some_method +# end +# end +# +# # good +# Struct.new do +# def some_method +# end +# end +# +# # good +# class Foo +# define_method(:foo) { puts 1 } +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:47 +class RuboCop::Cop::Style::TopLevelMethodDefinition < ::RuboCop::Cop::Base + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:79 + def define_method_block?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:60 + def on_block(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:52 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:52 + def on_defs(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:60 + def on_numblock(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:52 + def on_send(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:70 + def top_level_method_definition?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:48 +RuboCop::Cop::Style::TopLevelMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/top_level_method_definition.rb:50 +RuboCop::Cop::Style::TopLevelMethodDefinition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for trailing code after the class definition. +# +# @example +# # bad +# class Foo; def foo; end +# end +# +# # good +# class Foo +# def foo; end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_class.rb:18 +class RuboCop::Cop::Style::TrailingBodyOnClass < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_class.rb:25 + def on_class(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_class.rb:23 +RuboCop::Cop::Style::TrailingBodyOnClass::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing code after the method definition. +# +# NOTE: It always accepts endless method definitions that are basically on the same line. +# +# @example +# # bad +# def some_method; do_stuff +# end +# +# def f(x); b = foo +# b[c: x] +# end +# +# # good +# def some_method +# do_stuff +# end +# +# def f(x) +# b = foo +# b[c: x] +# end +# +# def endless_method = do_stuff +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_method_definition.rb:31 +class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_method_definition.rb:38 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_method_definition.rb:38 + def on_defs(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_method_definition.rb:36 +RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing code after the module definition. +# +# @example +# # bad +# module Foo extend self +# end +# +# # good +# module Foo +# extend self +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_module.rb:18 +class RuboCop::Cop::Style::TrailingBodyOnModule < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_module.rb:25 + def on_module(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_body_on_module.rb:23 +RuboCop::Cop::Style::TrailingBodyOnModule::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing comma in argument lists. +# The supported styles are: +# +# * `consistent_comma`: Requires a comma after the last argument, +# for all parenthesized method calls with arguments. +# * `comma`: Requires a comma after the last argument, but only for +# parenthesized method calls where each argument is on its own line. +# * `no_comma`: Requires that there is no comma after the last +# argument. +# +# @example EnforcedStyleForMultiline: consistent_comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: comma +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # bad +# method( +# 1, 2, +# 3, +# ) +# +# # good +# method( +# 1, 2, +# 3 +# ) +# +# # bad +# method( +# 1, 2, 3, +# ) +# +# # good +# method( +# 1, 2, 3 +# ) +# +# # good +# method( +# 1, +# 2, +# ) +# @example EnforcedStyleForMultiline: no_comma (default) +# # bad +# method(1, 2,) +# +# # good +# method(1, 2) +# +# # good +# method( +# 1, +# 2 +# ) +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_arguments.rb:87 +class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_arguments.rb:91 + def on_csend(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_arguments.rb:91 + def on_send(node); end + + class << self + # source://rubocop-rspec-2.12.1/lib/rubocop-rspec.rb:51 + def autocorrect_incompatible_with; end + end +end + +# Checks for trailing comma in array literals. +# The configuration options are: +# +# * `consistent_comma`: Requires a comma after the +# last item of all non-empty, multiline array literals. +# * `comma`: Requires a comma after last item in an array, +# but only when each item is on its own line. +# * `no_comma`: Does not require a comma after the +# last item in an array +# +# @example EnforcedStyleForMultiline: consistent_comma +# # bad +# a = [1, 2,] +# +# # good +# a = [1, 2] +# +# # good +# a = [ +# 1, 2, +# 3, +# ] +# +# # good +# a = [ +# 1, 2, 3, +# ] +# +# # good +# a = [ +# 1, +# 2, +# ] +# @example EnforcedStyleForMultiline: comma +# # bad +# a = [1, 2,] +# +# # good +# a = [1, 2] +# +# # bad +# a = [ +# 1, 2, +# 3, +# ] +# +# # good +# a = [ +# 1, 2, +# 3 +# ] +# +# # bad +# a = [ +# 1, 2, 3, +# ] +# +# # good +# a = [ +# 1, 2, 3 +# ] +# +# # good +# a = [ +# 1, +# 2, +# ] +# @example EnforcedStyleForMultiline: no_comma (default) +# # bad +# a = [1, 2,] +# +# # good +# a = [ +# 1, +# 2 +# ] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_array_literal.rb:84 +class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_array_literal.rb:88 + def on_array(node); end +end + +# Checks whether trailing commas in block arguments are +# required. Blocks with only one argument and a trailing comma require +# that comma to be present. Blocks with more than one argument never +# require a trailing comma. +# +# @example +# # bad +# add { |foo, bar,| foo + bar } +# +# # good +# add { |foo, bar| foo + bar } +# +# # good +# add { |foo,| foo } +# +# # good +# add { foo } +# +# # bad +# add do |foo, bar,| +# foo + bar +# end +# +# # good +# add do |foo, bar| +# foo + bar +# end +# +# # good +# add do |foo,| +# foo +# end +# +# # good +# add do +# foo + bar +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:62 +class RuboCop::Cop::Style::TrailingCommaInBlockArgs < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:67 + def on_block(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:83 + def arg_count(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:95 + def argument_tokens(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:91 + def last_comma(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:87 + def trailing_comma?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:79 + def useless_trailing_comma?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_block_args.rb:65 +RuboCop::Cop::Style::TrailingCommaInBlockArgs::MSG = T.let(T.unsafe(nil), String) + +# Checks for trailing comma in hash literals. +# The configuration options are: +# +# * `consistent_comma`: Requires a comma after the +# last item of all non-empty, multiline hash literals. +# * `comma`: Requires a comma after the last item in a hash, +# but only when each item is on its own line. +# * `no_comma`: Does not require a comma after the +# last item in a hash +# +# @example EnforcedStyleForMultiline: consistent_comma +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { foo: 1, bar: 2 } +# +# # good +# a = { +# foo: 1, bar: 2, +# qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, qux: 3, +# } +# +# # good +# a = { +# foo: 1, +# bar: 2, +# } +# @example EnforcedStyleForMultiline: comma +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { foo: 1, bar: 2 } +# +# # bad +# a = { +# foo: 1, bar: 2, +# qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, +# qux: 3 +# } +# +# # bad +# a = { +# foo: 1, bar: 2, qux: 3, +# } +# +# # good +# a = { +# foo: 1, bar: 2, qux: 3 +# } +# +# # good +# a = { +# foo: 1, +# bar: 2, +# } +# @example EnforcedStyleForMultiline: no_comma (default) +# +# # bad +# a = { foo: 1, bar: 2, } +# +# # good +# a = { +# foo: 1, +# bar: 2 +# } +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb:87 +class RuboCop::Cop::Style::TrailingCommaInHashLiteral < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::TrailingComma + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_comma_in_hash_literal.rb:91 + def on_hash(node); end +end + +# Checks for trailing code after the method definition. +# +# @example +# # bad +# def some_method +# do_stuff; end +# +# def do_this(x) +# baz.map { |b| b.this(x) } end +# +# def foo +# block do +# bar +# end end +# +# # good +# def some_method +# do_stuff +# end +# +# def do_this(x) +# baz.map { |b| b.this(x) } +# end +# +# def foo +# block do +# bar +# end +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_method_end_statement.rb:36 +class RuboCop::Cop::Style::TrailingMethodEndStatement < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_method_end_statement.rb:41 + def on_def(node); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_method_end_statement.rb:55 + def body_and_end_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_method_end_statement.rb:51 + def trailing_end?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_method_end_statement.rb:39 +RuboCop::Cop::Style::TrailingMethodEndStatement::MSG = T.let(T.unsafe(nil), String) + +# Checks for extra underscores in variable assignment. +# +# @example +# # bad +# a, b, _ = foo() +# a, b, _, = foo() +# a, _, _ = foo() +# a, _, _, = foo() +# +# # good +# a, b, = foo() +# a, = foo() +# *a, b, _ = foo() +# # => We need to know to not include 2 variables in a +# a, *b, _ = foo() +# # => The correction `a, *b, = foo()` is a syntax error +# @example AllowNamedUnderscoreVariables: true (default) +# # good +# a, b, _something = foo() +# @example AllowNamedUnderscoreVariables: false +# # bad +# a, b, _something = foo() +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:31 +class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:41 + def on_masgn(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:92 + def allow_named_underscore_variables; end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:125 + def children_offenses(variables); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:57 + def find_first_offense(variables); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:66 + def find_first_possible_offense(variables); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:108 + def main_node_offense(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:146 + def range_for_parentheses(offense, left); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:88 + def reverse_index(collection, item); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:80 + def splat_variable_before?(first_offense, variables); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:96 + def unneeded_ranges(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:133 + def unused_range(node_type, mlhs_node, right); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:129 + def unused_variables_only?(offense, variables); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:38 +RuboCop::Cop::Style::TrailingUnderscoreVariable::DISALLOW = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:36 +RuboCop::Cop::Style::TrailingUnderscoreVariable::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trailing_underscore_variable.rb:37 +RuboCop::Cop::Style::TrailingUnderscoreVariable::UNDERSCORE = T.let(T.unsafe(nil), String) + +# Looks for trivial reader/writer methods, that could +# have been created with the attr_* family of functions automatically. +# `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`, +# `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods +# are allowed by default. These are customizable with `AllowedMethods` option. +# +# @example AllowedMethods: ['allowed_method'] +# # good +# def allowed_method +# @foo +# end +# @example ExactNameMatch: true (default) +# # good +# def name +# @other_name +# end +# @example ExactNameMatch: false +# # bad +# def name +# @other_name +# end +# @example AllowPredicates: true (default) +# # good +# def foo? +# @foo +# end +# @example AllowPredicates: false +# # bad +# def foo? +# @foo +# end +# +# # good +# attr_reader :foo +# @example AllowDSLWriters: true (default) +# # good +# def on_exception(action) +# @on_exception=action +# end +# @example AllowDSLWriters: false +# # bad +# def on_exception(action) +# @on_exception=action +# end +# +# # good +# attr_writer :on_exception +# @example IgnoreClassMethods: false (default) +# # bad +# def self.foo +# @foo +# end +# +# # good +# class << self +# attr_reader :foo +# end +# @example IgnoreClassMethods: true +# # good +# def self.foo +# @foo +# end +# @example +# # bad +# def foo +# @foo +# end +# +# def bar=(val) +# @bar = val +# end +# +# def self.baz +# @baz +# end +# +# # good +# attr_reader :foo +# attr_writer :bar +# +# class << self +# attr_reader :baz +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:98 +class RuboCop::Cop::Style::TrivialAccessors < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:190 + def looks_like_trivial_writer?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:104 + def on_def(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:104 + def on_defs(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:222 + def accessor(kind, method_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:161 + def allow_dsl_writers?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:157 + def allow_predicates?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:195 + def allowed_method_name?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:169 + def allowed_method_names; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:204 + def allowed_reader?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:200 + def allowed_writer?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:142 + def autocorrect(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:234 + def autocorrect_class(corrector, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:226 + def autocorrect_instance(corrector, node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:173 + def dsl_writer?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:153 + def exact_name_match?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:165 + def ignore_class_methods?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:115 + def in_module_or_instance_eval?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:181 + def looks_like_trivial_reader?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:208 + def names_match?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:129 + def on_method_def(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:248 + def top_level_node?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:214 + def trivial_accessor_kind(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:177 + def trivial_reader?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:185 + def trivial_writer?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/trivial_accessors.rb:102 +RuboCop::Cop::Style::TrivialAccessors::MSG = T.let(T.unsafe(nil), String) + +# Looks for `unless` expressions with `else` clauses. +# +# @example +# # bad +# unless foo_bar.nil? +# # do something... +# else +# # do a different thing... +# end +# +# # good +# if foo_bar.present? +# # do something... +# else +# # do a different thing... +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/unless_else.rb:22 +class RuboCop::Cop::Style::UnlessElse < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_else.rb:28 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_else.rb:45 + def range_between_condition_and_else(node, condition); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_else.rb:49 + def range_between_else_and_end(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/unless_else.rb:26 +RuboCop::Cop::Style::UnlessElse::MSG = T.let(T.unsafe(nil), String) + +# Checks for the use of logical operators in an `unless` condition. +# It discourages such code, as the condition becomes more difficult +# to read and understand. +# +# This cop supports two styles: +# - `forbid_mixed_logical_operators` (default) +# - `forbid_logical_operators` +# +# `forbid_mixed_logical_operators` style forbids the use of more than one type +# of logical operators. This makes the `unless` condition easier to read +# because either all conditions need to be met or any condition need to be met +# in order for the expression to be truthy or falsey. +# +# `forbid_logical_operators` style forbids any use of logical operator. +# This makes it even more easy to read the `unless` condition as +# there is only one condition in the expression. +# +# @example EnforcedStyle: forbid_mixed_logical_operators (default) +# # bad +# return unless a || b && c +# return unless a && b || c +# return unless a && b and c +# return unless a || b or c +# return unless a && b or c +# return unless a || b and c +# +# # good +# return unless a && b && c +# return unless a || b || c +# return unless a and b and c +# return unless a or b or c +# return unless a? +# @example EnforcedStyle: forbid_logical_operators +# # bad +# return unless a || b +# return unless a && b +# return unless a or b +# return unless a and b +# +# # good +# return unless a +# return unless a? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:49 +class RuboCop::Cop::Style::UnlessLogicalOperators < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:61 + def and_with_or?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:66 + def logical_operator?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:70 + def on_if(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:56 + def or_with_and?(param0 = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:82 + def mixed_logical_operator?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:89 + def mixed_precedence_and?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:96 + def mixed_precedence_or?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:53 +RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/unless_logical_operators.rb:52 +RuboCop::Cop::Style::UnlessLogicalOperators::FORBID_MIXED_LOGICAL_OPERATORS = T.let(T.unsafe(nil), String) + +# Checks for accessing the first element of `String#unpack` +# which can be replaced with the shorter method `unpack1`. +# +# @example +# +# # bad +# 'foo'.unpack('h*').first +# 'foo'.unpack('h*')[0] +# 'foo'.unpack('h*').slice(0) +# 'foo'.unpack('h*').at(0) +# +# # good +# 'foo'.unpack1('h*') +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:20 +class RuboCop::Cop::Style::UnpackFirst < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:38 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:31 + def unpack_and_first_element?(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:54 + def first_element_range(node, unpack_call); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:26 +RuboCop::Cop::Style::UnpackFirst::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/unpack_first.rb:28 +RuboCop::Cop::Style::UnpackFirst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# Checks for variable interpolation (like "#@ivar"). +# +# @example +# # bad +# "His name is #$name" +# /check #$pattern/ +# "Let's go to the #@store" +# +# # good +# "His name is #{$name}" +# /check #{$pattern}/ +# "Let's go to the #{@store}" +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/variable_interpolation.rb:18 +class RuboCop::Cop::Style::VariableInterpolation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Interpolation + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/variable_interpolation.rb:25 + def on_node_with_interpolations(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/variable_interpolation.rb:35 + def message(range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/variable_interpolation.rb:39 + def var_nodes(nodes); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/variable_interpolation.rb:22 +RuboCop::Cop::Style::VariableInterpolation::MSG = T.let(T.unsafe(nil), String) + +# Checks for `when;` uses in `case` expressions. +# +# @example +# # bad +# case foo +# when 1; 'baz' +# when 2; 'bar' +# end +# +# # good +# case foo +# when 1 then 'baz' +# when 2 then 'bar' +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/when_then.rb:20 +class RuboCop::Cop::Style::WhenThen < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/when_then.rb:25 + def on_when(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/when_then.rb:23 +RuboCop::Cop::Style::WhenThen::MSG = T.let(T.unsafe(nil), String) + +# Checks for uses of `do` in multi-line `while/until` statements. +# +# @example +# +# # bad +# while x.any? do +# do_something(x.pop) +# end +# +# # good +# while x.any? +# do_something(x.pop) +# end +# @example +# +# # bad +# until x.empty? do +# do_something(x.pop) +# end +# +# # good +# until x.empty? +# do_something(x.pop) +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_do.rb:31 +class RuboCop::Cop::Style::WhileUntilDo < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_do.rb:36 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_do.rb:36 + def on_while(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_do.rb:34 +RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String) + +# Checks for while and until statements that would fit on one line +# if written as a modifier while/until. The maximum line length is +# configured in the `Layout/LineLength` cop. +# +# @example +# # bad +# while x < 10 +# x += 1 +# end +# +# # good +# x += 1 while x < 10 +# @example +# # bad +# until x > 10 +# x += 1 +# end +# +# # good +# x += 1 until x > 10 +# @example +# # bad +# x += 100 while x < 500 # a long comment that makes code too long if it were a single line +# +# # good +# while x < 500 # a long comment that makes code too long if it were a single line +# x += 100 +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_modifier.rb:36 +class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Base + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::StatementModifier + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_modifier.rb:42 + def on_until(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_modifier.rb:42 + def on_while(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/while_until_modifier.rb:40 +RuboCop::Cop::Style::WhileUntilModifier::MSG = T.let(T.unsafe(nil), String) + +# Checks for array literals made up of word-like +# strings, that are not using the %w() syntax. +# +# Alternatively, it can check for uses of the %w() syntax, in projects +# which do not want to include that syntax. +# +# NOTE: When using the `percent` style, %w() arrays containing a space +# will be registered as offenses. +# +# Configuration option: MinSize +# If set, arrays with fewer elements than this value will not trigger the +# cop. For example, a `MinSize` of `3` will not enforce a style on an +# array of 2 or fewer elements. +# +# @example EnforcedStyle: percent (default) +# # good +# %w[foo bar baz] +# +# # bad +# ['foo', 'bar', 'baz'] +# +# # bad (contains spaces) +# %w[foo\ bar baz\ quux] +# @example EnforcedStyle: brackets +# # good +# ['foo', 'bar', 'baz'] +# +# # bad +# %w[foo bar baz] +# +# # good (contains spaces) +# ['foo bar', 'baz quux'] +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:39 +class RuboCop::Cop::Style::WordArray < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:53 + def on_array(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:85 + def build_bracketed_array(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:65 + def complex_content?(strings, complex_regex: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:76 + def invalid_percent_array_contents?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:81 + def word_regex; end + + class << self + # Returns the value of attribute largest_brackets. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:50 + def largest_brackets; end + + # Sets the attribute largest_brackets + # + # @param value the value to set the attribute largest_brackets to. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:50 + def largest_brackets=(_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:47 +RuboCop::Cop::Style::WordArray::ARRAY_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/word_array.rb:46 +RuboCop::Cop::Style::WordArray::PERCENT_MSG = T.let(T.unsafe(nil), String) + +# Enforces or forbids Yoda conditions, +# i.e. comparison operations where the order of expression is reversed. +# eg. `5 == x` +# +# @example EnforcedStyle: forbid_for_all_comparison_operators (default) +# # bad +# 99 == foo +# "bar" != foo +# 42 >= foo +# 10 < bar +# +# # good +# foo == 99 +# foo == "bar" +# foo <= 42 +# bar > 10 +# "#{interpolation}" == foo +# /#{interpolation}/ == foo +# @example EnforcedStyle: forbid_for_equality_operators_only +# # bad +# 99 == foo +# "bar" != foo +# +# # good +# 99 >= foo +# 3 < a && a < 5 +# @example EnforcedStyle: require_for_all_comparison_operators +# # bad +# foo == 99 +# foo == "bar" +# foo <= 42 +# bar > 10 +# +# # good +# 99 == foo +# "bar" != foo +# 42 >= foo +# 10 < bar +# @example EnforcedStyle: require_for_equality_operators_only +# # bad +# 99 >= foo +# 3 < a && a < 5 +# +# # good +# 99 == foo +# "bar" != foo +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:75 +class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:88 + def file_constant_equal_program_name?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:92 + def on_send(node); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:140 + def actual_code_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:133 + def corrected_code(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:104 + def enforce_yoda?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:109 + def equality_only?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:164 + def interpolation?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:129 + def message(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:148 + def non_equality_operator?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:152 + def noncommutative_operator?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:160 + def program_name?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:144 + def reverse_comparison(operator); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:156 + def source_file_path_constant?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:118 + def valid_yoda?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:114 + def yoda_compatible_condition?(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:82 +RuboCop::Cop::Style::YodaCondition::EQUALITY_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:80 +RuboCop::Cop::Style::YodaCondition::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:83 +RuboCop::Cop::Style::YodaCondition::NONCOMMUTATIVE_OPERATORS = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:84 +RuboCop::Cop::Style::YodaCondition::PROGRAM_NAMES = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:85 +RuboCop::Cop::Style::YodaCondition::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/yoda_condition.rb:81 +RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Hash) + +# Checks for numeric comparisons that can be replaced +# by a predicate method, such as receiver.length == 0, +# receiver.length > 0, receiver.length != 0, +# receiver.length < 1 and receiver.size == 0 that can be +# replaced by receiver.empty? and !receiver.empty?. +# +# @example +# # bad +# [1, 2, 3].length == 0 +# 0 == "foobar".length +# array.length < 1 +# {a: 1, b: 2}.length != 0 +# string.length > 0 +# hash.size > 0 +# +# # good +# [1, 2, 3].empty? +# "foobar".empty? +# array.empty? +# !{a: 1, b: 2}.empty? +# !string.empty? +# !hash.empty? +# +# source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:34 +class RuboCop::Cop::Style::ZeroLengthPredicate < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + + # Some collection like objects in the Ruby standard library + # implement `#size`, but not `#empty`. We ignore those to + # reduce false positives. + # + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:118 + def non_polymorphic_collection?(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:88 + def nonzero_length_predicate(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:42 + def on_send(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:109 + def other_receiver(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:80 + def zero_length_predicate(param0 = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:101 + def zero_length_receiver(param0 = T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:64 + def check_nonzero_length_predicate(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:49 + def check_zero_length_predicate(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:93 + def replacement(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:38 +RuboCop::Cop::Style::ZeroLengthPredicate::NONZERO_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:40 +RuboCop::Cop::Style::ZeroLengthPredicate::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + +# source://rubocop-1.35.1/lib/rubocop/cop/style/zero_length_predicate.rb:37 +RuboCop::Cop::Style::ZeroLengthPredicate::ZERO_MSG = T.let(T.unsafe(nil), String) + +# Common functionality for checking and correcting surrounding whitespace. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:6 +module RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:109 + def empty_brackets?(left_bracket_token, right_bracket_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:103 + def empty_offense(node, range, message, command); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:93 + def empty_offenses(node, left, right, message); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:68 + def extra_space?(token, side); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:127 + def no_space_between?(left_bracket_token, right_bracket_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:38 + def no_space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:119 + def offending_empty_no_space?(config, left_token, right_token); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:115 + def offending_empty_space?(config, left_token, right_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:33 + def on_new_investigation; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:78 + def reposition(src, pos, step); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:16 + def side_space_range(range:, side:); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:123 + def space_between?(left_bracket_token, right_bracket_token); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:84 + def space_offense(node, token, side, message, command); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:53 + def space_offenses(node, left_token, right_token, message, start_ok: T.unsafe(nil), end_ok: T.unsafe(nil)); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:9 +RuboCop::Cop::SurroundingSpace::NO_SPACE_COMMAND = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:12 +RuboCop::Cop::SurroundingSpace::SINGLE_SPACE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/surrounding_space.rb:10 +RuboCop::Cop::SurroundingSpace::SPACE_COMMAND = T.let(T.unsafe(nil), String) + +# Classes that include this module just implement functions for working +# with symbol nodes. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/symbol_help.rb:7 +module RuboCop::Cop::SymbolHelp + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/symbol_help.rb:8 + def hash_key?(node); end +end + +# Common functionality for checking target ruby version. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/target_ruby_version.rb:6 +module RuboCop::Cop::TargetRubyVersion + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/target_ruby_version.rb:11 + def minimum_target_ruby_version(version); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/target_ruby_version.rb:7 + def required_minimum_ruby_version; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/target_ruby_version.rb:15 + def support_target_ruby_version?(version); end +end + +# A group of cops, ready to be called on duty to inspect files. +# Team is responsible for selecting only relevant cops to be sent on duty, +# as well as insuring that the needed forces are sent along with them. +# +# For performance reasons, Team will first dispatch cops & forces in two groups, +# first the ones needed for autocorrection (if any), then the rest +# (unless autocorrections happened). +# +# source://rubocop-1.35.1/lib/rubocop/cop/team.rb:12 +class RuboCop::Cop::Team + # @return [Team] a new instance of Team + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:17 + def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:51 + def autocorrect?; end + + # Returns the value of attribute cops. + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:13 + def cops; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:55 + def debug?; end + + # Returns the value of attribute errors. + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:13 + def errors; end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:113 + def external_dependency_checksum; end + + # @deprecated + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:94 + def forces; end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:61 + def inspect_file(processed_source); end + + # @return [Commissioner::InvestigationReport] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:66 + def investigate(processed_source); end + + # Returns the value of attribute updated_source_file. + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:13 + def updated_source_file; end + + # Returns the value of attribute updated_source_file. + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:13 + def updated_source_file?; end + + # Returns the value of attribute warnings. + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:13 + def warnings; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:120 + def autocorrect(processed_source, report); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:179 + def autocorrect_report(report); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:139 + def be_ready; end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:185 + def collate_corrections(report); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:197 + def each_corrector(report); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:247 + def handle_error(error, location, cop); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:239 + def handle_warning(error, location); end + + # @return [Commissioner::InvestigationReport] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:153 + def investigate_partial(cops, processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:224 + def process_errors(file, errors); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:147 + def reset; end + + # @return [Array<cop>] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:159 + def roundup_relevant_cops(filename); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:173 + def support_target_rails_version?(cop); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:167 + def support_target_ruby_version?(cop); end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:212 + def suppress_clobbering; end + + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:218 + def validate_config; end + + class << self + # @return [Array<Force>] needed for the given cops + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:99 + def forces_for(cops); end + + # @return [Team] with cops assembled from the given `cop_classes` + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:36 + def mobilize(cop_classes, config, options = T.unsafe(nil)); end + + # @return [Array<Cop::Cop>] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:42 + def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end + + # @return [Team] + # + # source://rubocop-1.35.1/lib/rubocop/cop/team.rb:28 + def new(cop_or_classes, config, options = T.unsafe(nil)); end + end +end + +# Common methods shared by TrailingBody cops +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_body.rb:6 +module RuboCop::Cop::TrailingBody + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_body.rb:12 + def body_on_first_line?(node, body); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_body.rb:16 + def first_part_of(body); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_body.rb:7 + def trailing_body?(node); end +end + +# Common methods shared by Style/TrailingCommaInArguments and +# Style/TrailingCommaInLiteral +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:7 +module RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + + private + + # A single argument with the closing bracket on the same line as the end + # of the argument is not considered multiline, even if the argument + # itself might span multiple lines. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:104 + def allowed_multiline_argument?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:167 + def any_heredoc?(items); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:159 + def autocorrect_range(item); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:133 + def avoid_comma(kind, comma_begin_pos, extra_info); end + + # Returns true if the node has round/square/curly brackets. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:82 + def brackets?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:19 + def check(node, items, kind, begin_pos, end_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:37 + def check_comma(node, kind, comma_pos); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:43 + def check_literal(node, kind); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:30 + def comma_offset(items, range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:108 + def elements(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:54 + def extra_avoid_comma_info; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:171 + def heredoc?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:189 + def heredoc_send?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:76 + def inside_comment?(range, comma_offset); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:93 + def method_name_and_arguments_on_same_line?(node); end + + # Returns true if the round/square/curly brackets of the given node are + # on different lines, each item within is on its own line, and the + # closing bracket is on its own line. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:89 + def multiline?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:123 + def no_elements_on_same_line?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:129 + def on_same_line?(range1, range2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:147 + def put_comma(items, kind); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:65 + def should_have_comma?(style, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:15 + def style_parameter_name; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/trailing_comma.rb:11 +RuboCop::Cop::TrailingComma::MSG = T.let(T.unsafe(nil), String) + +# Common functionality shared by Uncommunicative cops +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:6 +module RuboCop::Cop::UncommunicativeName + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:12 + def check(node, args); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:95 + def allow_nums; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:87 + def allowed_names; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:78 + def arg_range(arg, length); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:45 + def case_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:64 + def ends_with_num?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:91 + def forbidden_names; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:83 + def forbidden_offense(node, range, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:36 + def issue_offenses(node, range, name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:68 + def length_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:74 + def long_enough?(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:99 + def min_length; end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:53 + def name_type(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:60 + def num_offense(node, range); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:49 + def uppercase?(name); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:7 +RuboCop::Cop::UncommunicativeName::CASE_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:10 +RuboCop::Cop::UncommunicativeName::FORBIDDEN_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:9 +RuboCop::Cop::UncommunicativeName::LENGTH_MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/uncommunicative_name.rb:8 +RuboCop::Cop::UncommunicativeName::NUM_MSG = T.let(T.unsafe(nil), String) + +# This autocorrects unused arguments. +# +# source://rubocop-1.35.1/lib/rubocop/cop/correctors/unused_arg_corrector.rb:6 +class RuboCop::Cop::UnusedArgCorrector + extend ::RuboCop::Cop::RangeHelp + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/unused_arg_corrector.rb:12 + def correct(corrector, processed_source, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/unused_arg_corrector.rb:31 + def correct_for_blockarg_type(corrector, node); end + + # Returns the value of attribute processed_source. + # + # source://rubocop-1.35.1/lib/rubocop/cop/correctors/unused_arg_corrector.rb:10 + def processed_source; end + end +end + +# This module contains a collection of useful utility methods. +# +# source://rubocop-1.35.1/lib/rubocop/cop/util.rb:6 +module RuboCop::Cop::Util + include ::RuboCop::PathUtil + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:34 + def add_parentheses(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:55 + def args_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:67 + def args_end(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:80 + def begins_its_line?(range); end + + # This is a bad API + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:16 + def comment_line?(line_source); end + + # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:21 + def comment_lines?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:161 + def compatible_external_encoding_for?(src); end + + # If converting a string to Ruby string literal source code, must + # double quotes be used? + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:102 + def double_quotes_required?(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:116 + def escape_string(string); end + + # Returns, for example, a bare `if` node if the given node is an `if` + # with calls chained to the end of it. + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:86 + def first_part_of_call_chain(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:151 + def indent(node, offset: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:133 + def interpret_string_escapes(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:137 + def line(node_or_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:25 + def line_range(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:112 + def needs_escaping?(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:71 + def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:29 + def parentheses?(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:145 + def same_line?(node1, node2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:120 + def to_string_literal(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:155 + def to_supported_styles(enforced_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:129 + def trim_string_interpolation_escape_character(str); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:34 + def add_parentheses(node, corrector); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:55 + def args_begin(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:67 + def args_end(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:80 + def begins_its_line?(range); end + + # This is a bad API + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:16 + def comment_line?(line_source); end + + # @deprecated Use `ProcessedSource#line_with_comment?`, `contains_comment?` or similar + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:21 + def comment_lines?(node); end + + # If converting a string to Ruby string literal source code, must + # double quotes be used? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:102 + def double_quotes_required?(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:116 + def escape_string(string); end + + # Returns, for example, a bare `if` node if the given node is an `if` + # with calls chained to the end of it. + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:86 + def first_part_of_call_chain(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:151 + def indent(node, offset: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:133 + def interpret_string_escapes(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:137 + def line(node_or_range); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:25 + def line_range(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:112 + def needs_escaping?(string); end + + # @yield [sexp] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:71 + def on_node(syms, sexp, excludes = T.unsafe(nil), &block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:29 + def parentheses?(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:145 + def same_line?(node1, node2); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:120 + def to_string_literal(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:155 + def to_supported_styles(enforced_style); end + + # source://rubocop-1.35.1/lib/rubocop/cop/util.rb:129 + def trim_string_interpolation_escape_character(str); end + end +end + +# Match literal regex characters, not including anchors, character +# classes, alternatives, groups, repetitions, references, etc +# +# source://rubocop-1.35.1/lib/rubocop/cop/util.rb:11 +RuboCop::Cop::Util::LITERAL_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:5 +module RuboCop::Cop::Utils; end + +# Parses {Kernel#sprintf} format strings. +# +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:7 +class RuboCop::Cop::Utils::FormatString + # @return [FormatString] a new instance of FormatString + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:89 + def initialize(string); end + + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:93 + def format_sequences; end + + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:105 + def max_digit_dollar_num; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:101 + def named_interpolation?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:97 + def valid?; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:117 + def mixed_formats?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:111 + def parse; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:8 +RuboCop::Cop::Utils::FormatString::DIGIT_DOLLAR = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:9 +RuboCop::Cop::Utils::FormatString::FLAG = T.let(T.unsafe(nil), Regexp) + +# The syntax of a format sequence is as follows. +# +# ``` +# %[flags][width][.precision]type +# ``` +# +# A format sequence consists of a percent sign, followed by optional +# flags, width, and precision indicators, then terminated with a field +# type character. +# +# For more complex formatting, Ruby supports a reference by name. +# +# @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format +# +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:43 +class RuboCop::Cop::Utils::FormatString::FormatSequence + # @return [FormatSequence] a new instance of FormatSequence + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:46 + def initialize(match); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:61 + def annotated?; end + + # Number of arguments required for the format sequence + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:70 + def arity; end + + # Returns the value of attribute begin_pos. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def begin_pos; end + + # Returns the value of attribute end_pos. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def end_pos; end + + # Returns the value of attribute flags. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def flags; end + + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:74 + def max_digit_dollar_num; end + + # Returns the value of attribute name. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def name; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:57 + def percent?; end + + # Returns the value of attribute precision. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def precision; end + + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:78 + def style; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:65 + def template?; end + + # Returns the value of attribute type. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def type; end + + # Returns the value of attribute width. + # + # source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:44 + def width; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:15 +RuboCop::Cop::Utils::FormatString::NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:11 +RuboCop::Cop::Utils::FormatString::NUMBER = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:10 +RuboCop::Cop::Utils::FormatString::NUMBER_ARG = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:13 +RuboCop::Cop::Utils::FormatString::PRECISION = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:18 +RuboCop::Cop::Utils::FormatString::SEQUENCE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:16 +RuboCop::Cop::Utils::FormatString::TEMPLATE_NAME = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:14 +RuboCop::Cop::Utils::FormatString::TYPE = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/cop/utils/format_string.rb:12 +RuboCop::Cop::Utils::FormatString::WIDTH = T.let(T.unsafe(nil), Regexp) + +# This force provides a way to track local variables and scopes of Ruby. +# Cops interact with this force need to override some of the hook methods. +# +# def before_entering_scope(scope, variable_table) +# end +# +# def after_entering_scope(scope, variable_table) +# end +# +# def before_leaving_scope(scope, variable_table) +# end +# +# def after_leaving_scope(scope, variable_table) +# end +# +# def before_declaring_variable(variable, variable_table) +# end +# +# def after_declaring_variable(variable, variable_table) +# end +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:27 +class RuboCop::Cop::VariableForce < ::RuboCop::Cop::Force + # Starting point. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:75 + def investigate(processed_source); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:84 + def process_node(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:70 + def variable_table; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def after_declaring_variable(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def after_entering_scope(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def after_leaving_scope(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def before_declaring_variable(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def before_entering_scope(arg); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:379 + def before_leaving_scope(arg); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:349 + def descendant_reference(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:339 + def each_descendant_reference(loop_node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:324 + def find_variables_in_loop(loop_node); end + + # This is called for each scope recursively. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:93 + def inspect_variables_in_scope(scope_node); end + + # Mark all assignments which are referenced in the same loop + # as referenced by ignoring AST order since they would be referenced + # in next iteration. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:305 + def mark_assignments_as_referenced_in_loop(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:112 + def node_handler_method_name(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:99 + def process_children(origin_node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:241 + def process_loop(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:170 + def process_regexp_named_captures(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:256 + def process_rescue(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:275 + def process_scope(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:294 + def process_send(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:152 + def process_variable_assignment(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:140 + def process_variable_declaration(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:229 + def process_variable_multiple_assignment(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:194 + def process_variable_operator_assignment(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:236 + def process_variable_referencing(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:267 + def process_zero_arity_super(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:188 + def regexp_captured_names(node); end + + # Use Node#equal? for accurate check. + # + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:362 + def scanned_node?(node); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:366 + def scanned_nodes; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:107 + def skip_children!; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:288 + def twisted_nodes(node); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:32 +RuboCop::Cop::VariableForce::ARGUMENT_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +# This class represents each assignment of a variable. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:7 +class RuboCop::Cop::VariableForce::Assignment + include ::RuboCop::Cop::VariableForce::Branchable + + # @return [Assignment] a new instance of Assignment + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:16 + def initialize(node, variable); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:67 + def meta_assignment_node; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:56 + def multiple_assignment?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:29 + def name; end + + # Returns the value of attribute node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:12 + def node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:62 + def operator; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:50 + def operator_assignment?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:37 + def reference!(node); end + + # Returns the value of attribute referenced. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:12 + def referenced; end + + # Returns the value of attribute referenced. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:12 + def referenced?; end + + # Returns the value of attribute references. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:12 + def references; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:46 + def regexp_named_capture?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:33 + def scope; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:42 + def used?; end + + # Returns the value of attribute variable. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:12 + def variable; end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:85 + def multiple_assignment_node; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:77 + def operator_assignment_node; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/assignment.rb:10 +RuboCop::Cop::VariableForce::Assignment::MULTIPLE_LEFT_HAND_SIDE_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:64 +class RuboCop::Cop::VariableForce::AssignmentReference < ::Struct + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:65 + def assignment?; end + + # Returns the value of attribute node + # + # @return [Object] the current value of node + def node; end + + # Sets the attribute node + # + # @param value [Object] the value to set the attribute node to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:64 + def node=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# Namespace for branch classes for each control structure. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:7 +module RuboCop::Cop::VariableForce::Branch + class << self + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:8 + def of(target_node, scope: T.unsafe(nil)); end + end +end + +# left_body && right_body +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:265 +class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def left_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def right_body?; end +end + +# Abstract base class for branch classes. +# A branch represents a conditional branch in a scope. +# +# @example +# def some_scope +# do_something # no branch +# +# if foo +# do_something # branch A +# do_something # branch A +# else +# do_something # branch B +# if bar +# do_something # branch C (whose parent is branch B) +# end +# end +# +# do_something # no branch +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:42 +class RuboCop::Cop::VariableForce::Branch::Base < ::Struct + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:121 + def ==(other); end + + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:92 + def always_run?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:88 + def branched?; end + + # Returns the value of attribute child_node + # + # @return [Object] the current value of child_node + def child_node; end + + # Sets the attribute child_node + # + # @param value [Object] the value to set the attribute child_node to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:42 + def child_node=(_); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:70 + def control_node; end + + # @yield [_self] + # @yieldparam _self [RuboCop::Cop::VariableForce::Branch::Base] the object that the method was called on + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:80 + def each_ancestor(include_self: T.unsafe(nil), &block); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:121 + def eql?(other); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:104 + def exclusive_with?(other); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:129 + def hash; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:96 + def may_jump_to_other_branch?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:100 + def may_run_incompletely?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:74 + def parent; end + + # Returns the value of attribute scope + # + # @return [Object] the current value of scope + def scope; end + + # Sets the attribute scope + # + # @param value [Object] the value to set the attribute scope to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:42 + def scope=(_); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:135 + def scan_ancestors; end + + class << self + def [](*_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:43 + def classes; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:56 + def define_predicate(name, child_index: T.unsafe(nil)); end + + # @private + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:47 + def inherited(subclass); end + + def inspect; end + def members; end + def new(*_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:52 + def type; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:325 +RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash) + +# case target +# when /pattern/ # when_clause +# else +# else_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:219 +class RuboCop::Cop::VariableForce::Branch::Case < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:224 + def always_run?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def else_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def target?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def when_clause?; end +end + +# case target +# in pattern # in_pattern +# else +# else_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:234 +class RuboCop::Cop::VariableForce::Branch::CaseMatch < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:239 + def always_run?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def else_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def in_pattern?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def target?; end +end + +# begin +# main_body +# ensure +# ensure_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:314 +class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:320 + def always_run?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def ensure_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def main_body?; end +end + +# Mix-in module for exception handling control structures. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:281 +module RuboCop::Cop::VariableForce::Branch::ExceptionHandler + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:282 + def may_jump_to_other_branch?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:286 + def may_run_incompletely?; end +end + +# for element in collection +# loop_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:247 +class RuboCop::Cop::VariableForce::Branch::For < ::RuboCop::Cop::VariableForce::Branch::Base + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:252 + def always_run?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def collection?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def element?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def loop_body?; end +end + +# if conditional_clause +# truthy_body +# else +# falsey_body +# end +# +# unless conditional_clause +# falsey_body +# else +# truthy_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:166 +class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def conditional_clause?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def falsey_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def truthy_body?; end +end + +# Mix-in module for logical operator control structures. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:258 +module RuboCop::Cop::VariableForce::Branch::LogicalOperator + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:259 + def always_run?; end +end + +# left_body || right_body +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:273 +class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def left_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def right_body?; end +end + +# begin +# main_body +# rescue StandardError => error # rescue_clause +# else +# else_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:297 +class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:304 + def always_run?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def else_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def main_body?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def rescue_clause?; end +end + +# Mix-in module for simple conditional control structures. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:145 +module RuboCop::Cop::VariableForce::Branch::SimpleConditional + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:150 + def always_run?; end + + # @raise [NotImplementedError] + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:146 + def conditional_clause?; end +end + +# until conditional_clause +# loop_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:187 +class RuboCop::Cop::VariableForce::Branch::Until < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def conditional_clause?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def loop_body?; end +end + +# begin +# loop_body +# end until conditional_clause +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:207 +class RuboCop::Cop::VariableForce::Branch::UntilPost < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def conditional_clause?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def loop_body?; end +end + +# while conditional_clause +# loop_body +# end +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:177 +class RuboCop::Cop::VariableForce::Branch::While < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def conditional_clause?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def loop_body?; end +end + +# begin +# loop_body +# end while conditional_clause +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:197 +class RuboCop::Cop::VariableForce::Branch::WhilePost < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def conditional_clause?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branch.rb:57 + def loop_body?; end +end + +# Mix-in module for classes which own a node and need branch information +# of the node. The user classes must implement #node and #scope. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branchable.rb:8 +module RuboCop::Cop::VariableForce::Branchable + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branchable.rb:9 + def branch; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/branchable.rb:15 + def run_exclusively_with?(other); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:39 +RuboCop::Cop::VariableForce::LOGICAL_OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:47 +RuboCop::Cop::VariableForce::LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:42 +RuboCop::Cop::VariableForce::MULTIPLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:40 +RuboCop::Cop::VariableForce::OPERATOR_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:46 +RuboCop::Cop::VariableForce::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:29 +RuboCop::Cop::VariableForce::REGEXP_NAMED_CAPTURE_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:49 +RuboCop::Cop::VariableForce::RESCUE_TYPE = T.let(T.unsafe(nil), Symbol) + +# This class represents each reference of a variable. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:7 +class RuboCop::Cop::VariableForce::Reference + include ::RuboCop::Cop::VariableForce::Branchable + + # @return [Reference] a new instance of Reference + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:16 + def initialize(node, scope); end + + # There's an implicit variable reference by the zero-arity `super`: + # + # def some_method(foo) + # super + # end + # + # Another case is `binding`: + # + # def some_method(foo) + # do_something(binding) + # end + # + # In these cases, the variable `foo` is not explicitly referenced, + # but it can be considered used implicitly by the `super` or `binding`. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:41 + def explicit?; end + + # Returns the value of attribute node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:14 + def node; end + + # Returns the value of attribute scope. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:14 + def scope; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/reference.rb:10 +RuboCop::Cop::VariableForce::Reference::VARIABLE_REFERENCE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:54 +RuboCop::Cop::VariableForce::SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:56 +RuboCop::Cop::VariableForce::SEND_TYPE = T.let(T.unsafe(nil), Symbol) + +# A Scope represents a context of local variable visibility. +# This is a place where local variables belong to. +# A scope instance holds a scope node and variable entries. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:9 +class RuboCop::Cop::VariableForce::Scope + # @return [Scope] a new instance of Scope + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:22 + def initialize(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:35 + def ==(other); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:43 + def body_node; end + + # @yield [node] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:61 + def each_node(&block); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:57 + def include?(target_node); end + + # Returns the value of attribute naked_top_level. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:18 + def naked_top_level; end + + # Returns the value of attribute naked_top_level. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:18 + def naked_top_level?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:39 + def name; end + + # Returns the value of attribute node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:18 + def node; end + + # Returns the value of attribute variables. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:18 + def variables; end + + private + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:100 + def ancestor_node?(target_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:90 + def belong_to_inner_scope?(target_node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:79 + def belong_to_outer_scope?(target_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:70 + def scan_node(node, &block); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/scope.rb:10 +RuboCop::Cop::VariableForce::Scope::OUTER_SCOPE_CHILD_INDICES = T.let(T.unsafe(nil), Hash) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:53 +RuboCop::Cop::VariableForce::TWISTED_SCOPE_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:28 +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPE = T.let(T.unsafe(nil), Symbol) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:30 +RuboCop::Cop::VariableForce::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:44 +RuboCop::Cop::VariableForce::VARIABLE_REFERENCE_TYPE = T.let(T.unsafe(nil), Symbol) + +# A Variable represents existence of a local variable. +# This holds a variable declaration node and some states of the variable. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:8 +class RuboCop::Cop::VariableForce::Variable + # @return [Variable] a new instance of Variable + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:15 + def initialize(name, declaration_node, scope); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:92 + def argument?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:31 + def assign(node); end + + # Returns the value of attribute assignments. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def assignments; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:100 + def block_argument?; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:72 + def capture_with_block!; end + + # Returns the value of attribute captured_by_block. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def captured_by_block; end + + # Returns the value of attribute captured_by_block. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def captured_by_block?; end + + # Returns the value of attribute declaration_node. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def declaration_node; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:108 + def explicit_block_local_variable?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:66 + def in_modifier_if?(assignment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:104 + def keyword_argument?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:96 + def method_argument?; end + + # Returns the value of attribute name. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def name; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:40 + def reference!(node); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:35 + def referenced?; end + + # Returns the value of attribute references. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def references; end + + # Returns the value of attribute scope. + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:11 + def scope; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:88 + def should_be_unused?; end + + # This is a convenient way to check whether the variable is used + # in its entire variable lifetime. + # For more precise usage check, refer Assignment#used?. + # + # Once the variable is captured by a block, we have no idea + # when, where, and how many times the block would be invoked. + # This means we cannot track the usage of the variable. + # So we consider it's used to suppress false positive offenses. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:84 + def used?; end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable.rb:9 +RuboCop::Cop::VariableForce::Variable::VARIABLE_DECLARATION_TYPES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:58 +class RuboCop::Cop::VariableForce::VariableReference < ::Struct + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:59 + def assignment?; end + + # Returns the value of attribute name + # + # @return [Object] the current value of name + def name; end + + # Sets the attribute name + # + # @param value [Object] the value to set the attribute name to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:58 + def name=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# A VariableTable manages the lifetime of all scopes and local variables +# in a program. +# This holds scopes as stack structure, provides a way to add local +# variables to current scope, and find local variables by considering +# variable visibility of the current scope. +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:11 +class RuboCop::Cop::VariableForce::VariableTable + # @return [VariableTable] a new instance of VariableTable + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:12 + def initialize(hook_receiver = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:111 + def accessible_variables; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:56 + def assign_to_variable(name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:40 + def current_scope; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:44 + def current_scope_level; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:48 + def declare_variable(name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:94 + def find_variable(name); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:16 + def invoke_hook(hook_name, *args); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:32 + def pop_scope; end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:24 + def push_scope(scope_node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:68 + def reference_variable(name, node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:20 + def scope_stack; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:107 + def variable_exist?(name); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/variable_force/variable_table.rb:120 + def mark_variable_as_captured_by_block_if_so(variable); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/cop/variable_force.rb:51 +RuboCop::Cop::VariableForce::ZERO_ARITY_SUPER_TYPE = T.let(T.unsafe(nil), Symbol) + +# Help methods for determining node visibility. +# +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:6 +module RuboCop::Cop::VisibilityHelp + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:32 + def visibility_block?(param0 = T.unsafe(nil)); end + + private + + # Navigate to find the last protected method + # + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:23 + def find_visibility_end(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:18 + def find_visibility_start(node); end + + # source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:13 + def node_visibility(node); end +end + +# source://rubocop-1.35.1/lib/rubocop/cop/mixin/visibility_help.rb:9 +RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Array) + +# This class wraps the `Parser::Source::Comment` object that represents a +# cops it contains. +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:7 +class RuboCop::DirectiveComment + # @return [DirectiveComment] a new instance of DirectiveComment + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:30 + def initialize(comment, cop_registry = T.unsafe(nil)); end + + # Checks if all cops specified in this directive + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:80 + def all_cops?; end + + # Returns the value of attribute comment. + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:28 + def comment; end + + # Returns array of specified in this directive cop names + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:85 + def cop_names; end + + # Returns the value of attribute cop_registry. + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:28 + def cop_registry; end + + # Returns the value of attribute cops. + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:28 + def cops; end + + # Returns array of specified in this directive department names + # when all department disabled + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:91 + def department_names; end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:105 + def directive_count; end + + # Checks if this directive disables cops + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:60 + def disabled?; end + + # Checks if this directive disables all cops + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:75 + def disabled_all?; end + + # Checks if this directive enables cops + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:65 + def enabled?; end + + # Checks if this directive enables all cops + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:70 + def enabled_all?; end + + # Checks if directive departments include cop + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:96 + def in_directive_department?(cop); end + + # Returns line number for directive + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:110 + def line_number; end + + # Checks if this directive contains all the given cop names + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:42 + def match?(cop_names); end + + # Returns match captures to directive comment pattern + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:55 + def match_captures; end + + # Returns the value of attribute mode. + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:28 + def mode; end + + # Checks if cop department has already used in directive comment + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:101 + def overridden_by_department?(cop); end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:46 + def range; end + + # Checks if this directive relates to single line + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:37 + def single_line?; end + + private + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:130 + def all_cop_names; end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:134 + def cop_names_for_department(department); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:126 + def department?(name); end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:140 + def exclude_redundant_directive_cop(cops); end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:120 + def parsed_cop_names; end + + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:116 + def splitted_cops_string; end + + class << self + # source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:24 + def before_comment(line); end + end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:17 +RuboCop::DirectiveComment::COPS_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:15 +RuboCop::DirectiveComment::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:13 +RuboCop::DirectiveComment::COP_NAME_PATTERN = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:19 +RuboCop::DirectiveComment::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:11 +RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/directive_comment.rb:9 +RuboCop::DirectiveComment::REDUNDANT_DIRECTIVE_COP_DEPARTMENT = T.let(T.unsafe(nil), String) + +# An Error exception is different from an Offense with severity 'error' +# When this exception is raised, it means that RuboCop is unable to perform +# a requested action (probably due to misconfiguration) and must stop +# immediately, rather than carrying on +# +# source://rubocop-1.35.1/lib/rubocop/error.rb:8 +class RuboCop::Error < ::StandardError; end + +# A wrapper to display errored location of analyzed file. +# +# source://rubocop-1.35.1/lib/rubocop/error.rb:13 +class RuboCop::ErrorWithAnalyzedFileLocation < ::RuboCop::Error + # @return [ErrorWithAnalyzedFileLocation] a new instance of ErrorWithAnalyzedFileLocation + # + # source://rubocop-1.35.1/lib/rubocop/error.rb:14 + def initialize(cause:, node:, cop:); end + + # Returns the value of attribute cause. + # + # source://rubocop-1.35.1/lib/rubocop/error.rb:21 + def cause; end + + # source://rubocop-1.35.1/lib/rubocop/error.rb:27 + def column; end + + # Returns the value of attribute cop. + # + # source://rubocop-1.35.1/lib/rubocop/error.rb:21 + def cop; end + + # source://rubocop-1.35.1/lib/rubocop/error.rb:23 + def line; end + + # source://rubocop-1.35.1/lib/rubocop/error.rb:31 + def message; end +end + +# Allows specified configuration options to have an exclude limit +# ie. a maximum value tracked that it can be used by `--auto-gen-config`. +# +# source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:6 +module RuboCop::ExcludeLimit + # Sets up a configuration option to have an exclude limit tracked. + # The parameter name given is transformed into a method name (eg. `Max` + # becomes `self.max=` and `MinDigits` becomes `self.min_digits=`). + # + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:10 + def exclude_limit(parameter_name, method_name: T.unsafe(nil)); end + + private + + # source://rubocop-1.35.1/lib/rubocop/cop/exclude_limit.rb:22 + def transform(parameter_name); end +end + +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:4 +module RuboCop::Ext; end + +# Extensions to AST::ProcessedSource for our cached comment_config +# +# source://rubocop-1.35.1/lib/rubocop/ext/processed_source.rb:6 +module RuboCop::Ext::ProcessedSource + # source://rubocop-1.35.1/lib/rubocop/ext/processed_source.rb:7 + def comment_config; end + + # source://rubocop-1.35.1/lib/rubocop/ext/processed_source.rb:11 + def disabled_line_ranges; end +end + +# Extensions to Parser::Source::Range +# +# source://rubocop-1.35.1/lib/rubocop/ext/range.rb:6 +module RuboCop::Ext::Range + # Adds `Range#single_line?` to parallel `Node#single_line?` + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/ext/range.rb:8 + def single_line?; end +end + +# Extensions to AST::RegexpNode for our cached parsed regexp info +# +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:6 +module RuboCop::Ext::RegexpNode + # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped. + # It's for compatibility with regexp_arser 1.8 and will never be maintained. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:19 + def assign_properties(*_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:53 + def each_capture(named: T.unsafe(nil)); end + + # Note: we extend Regexp nodes to provide `loc` and `expression` + # see `ext/regexp_parser`. + # + # @return [Regexp::Expression::Root, nil] + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:16 + def parsed_tree; end + + private + + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:68 + def with_interpolations_blanked; end +end + +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_node.rb:7 +RuboCop::Ext::RegexpNode::ANY = T.let(T.unsafe(nil), Object) + +# Extensions for `regexp_parser` gem +# +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:6 +module RuboCop::Ext::RegexpParser; end + +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:20 +module RuboCop::Ext::RegexpParser::Expression; end + +# Add `expression` and `loc` to all `regexp_parser` nodes +# +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:22 +module RuboCop::Ext::RegexpParser::Expression::Base + # Shortcut to `loc.expression` + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:27 + def expression; end + + # E.g. + # [a-z]{2,} + # ^^^^^^^^^ expression + # ^^^^ quantifier + # ^^^^^ body + # ^ begin + # ^ end + # + # Please open issue if you need other locations + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:61 + def loc; end + + # Returns the value of attribute origin. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:23 + def origin; end + + # Sets the attribute origin + # + # @param value the value to set the attribute origin to. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:23 + def origin=(_arg0); end + + private + + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:67 + def build_location; end +end + +# Provide `CharacterSet` with `begin` and `end` locations. +# +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:77 +module RuboCop::Ext::RegexpParser::Expression::CharacterSet + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:78 + def build_location; end +end + +# Source map for RegexpParser nodes +# +# source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:8 +class RuboCop::Ext::RegexpParser::Map < ::Parser::Source::Map + # @return [Map] a new instance of Map + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:11 + def initialize(expression, body:, quantifier: T.unsafe(nil), begin_l: T.unsafe(nil), end_l: T.unsafe(nil)); end + + # Returns the value of attribute begin. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:9 + def begin; end + + # Returns the value of attribute body. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:9 + def body; end + + # Returns the value of attribute end. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:9 + def end; end + + # Returns the value of attribute quantifier. + # + # source://rubocop-1.35.1/lib/rubocop/ext/regexp_parser.rb:9 + def quantifier; end +end + +# This class handles loading files (a.k.a. features in Ruby) specified +# by `--require` command line option and `require` directive in the config. +# +# Normally, the given string is directly passed to `require`. If a string +# beginning with `.` is given, it is assumed to be relative to the given +# directory. +# +# If a string containing `-` is given, it will be used as is, but if we +# cannot find the file to load, we will replace `-` with `/` and try it +# again as when Bundler loads gems. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:16 +class RuboCop::FeatureLoader + # @api private + # @param config_directory_path [String] + # @param feature [String] + # @return [FeatureLoader] a new instance of FeatureLoader + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:27 + def initialize(config_directory_path:, feature:); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:32 + def load; end + + private + + # @api private + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:55 + def namespaced_feature; end + + # @api private + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:60 + def namespaced_target; end + + # @api private + # @param [String] + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:70 + def relative(feature); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:75 + def relative?; end + + # @api private + # @param error [LoadError] + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:81 + def seems_cannot_load_such_file_error?(error); end + + # @api private + # @return [String] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:86 + def target; end + + class << self + # @api private + # @param config_directory_path [String] + # @param feature [String] + # + # source://rubocop-1.35.1/lib/rubocop/feature_loader.rb:20 + def load(config_directory_path:, feature:); end + end +end + +# Common methods for finding files. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/file_finder.rb:8 +module RuboCop::FileFinder + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/file_finder.rb:17 + def find_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/file_finder.rb:24 + def find_last_file_upwards(filename, start_dir, stop_dir = T.unsafe(nil)); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/file_finder.rb:32 + def traverse_files_upwards(filename, start_dir, stop_dir); end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/file_finder.rb:9 + def root_level=(level); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/file_finder.rb:13 + def root_level?(path, stop_dir); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter.rb:4 +module RuboCop::Formatter; end + +# Does not show individual offenses in the console. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/auto_gen_config_formatter.rb:6 +class RuboCop::Formatter::AutoGenConfigFormatter < ::RuboCop::Formatter::ProgressFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/auto_gen_config_formatter.rb:7 + def finished(inspected_files); end +end + +# Abstract base class for formatter, implements all public API methods. +# +# ## Creating Custom Formatter +# +# You can create a custom formatter by subclassing +# `RuboCop::Formatter::BaseFormatter` and overriding some methods +# or by implementing all the methods by duck typing. +# +# ## Using Custom Formatter in Command Line +# +# You can tell RuboCop to use your custom formatter with a combination of +# `--format` and `--require` option. +# For example, when you have defined `MyCustomFormatter` in +# `./path/to/my_custom_formatter.rb`, you would type this command: +# +# rubocop --require ./path/to/my_custom_formatter --format MyCustomFormatter +# +# Note: The path passed to `--require` is directly passed to +# `Kernel.require`. +# If your custom formatter file is not in `$LOAD_PATH`, +# you need to specify the path as relative path prefixed with `./` +# explicitly or absolute path. +# +# ## Method Invocation Order +# +# For example, when RuboCop inspects 2 files, +# the invocation order should be like this: +# +# * `#initialize` +# * `#started` +# * `#file_started` +# * `#file_finished` +# * `#file_started` +# * `#file_finished` +# * `#finished` +# +# source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:41 +class RuboCop::Formatter::BaseFormatter + # @api public + # @param output [IO] `$stdout` or opened file + # @return [BaseFormatter] a new instance of BaseFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:63 + def initialize(output, options = T.unsafe(nil)); end + + # Invoked at the end of inspecting each files. + # + # @api public + # @param file [String] the file path + # @param offenses [Array(RuboCop::Cop::Offense)] all detected offenses for the file + # @return [void] + # @see RuboCop::Cop::Offense + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:104 + def file_finished(file, offenses); end + + # Invoked at the beginning of inspecting each files. + # + # @api public + # @param file [String] the file path + # @param options [Hash] file specific information, currently this is always empty. + # @return [void] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:89 + def file_started(file, options); end + + # Invoked after all files are inspected or interrupted by user. + # + # @api public + # @param inspected_files [Array(String)] the inspected file paths. + # This would be same as `target_files` passed to `#started` + # unless RuboCop is interrupted by user. + # @return [void] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:116 + def finished(inspected_files); end + + # @api public + # @return [Hash] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:57 + def options; end + + # @api public + # @return [IO] the IO object passed to `#initialize` + # @see #initialize + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:50 + def output; end + + # Invoked once before any files are inspected. + # + # @api public + # @param target_files [Array(String)] all target file paths to be inspected + # @return [void] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/base_formatter.rb:76 + def started(target_files); end +end + +# This formatter formats report data in clang style. +# The precise location of the problem is shown together with the +# relevant source code. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:8 +class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleTextFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:11 + def report_file(file, offenses); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:51 + def report_highlighted_area(highlighted_area); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:41 + def report_line(location); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:17 + def report_offense(file, offense); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:37 + def valid_line?(offense); end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/clang_style_formatter.rb:9 +RuboCop::Formatter::ClangStyleFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +# This mix-in module provides string coloring methods for terminals. +# It automatically disables coloring if coloring is disabled in the process +# globally or the formatter's output is not a terminal. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:8 +module RuboCop::Formatter::Colorizable + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def black(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def blue(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:21 + def colorize(string, *args); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def cyan(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def green(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def magenta(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:9 + def rainbow; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def red(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def white(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/colorizable.rb:35 + def yellow(string); end +end + +# This formatter displays a YAML configuration file where all cops that +# detected any offenses are configured to not detect the offense. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:7 +class RuboCop::Formatter::DisabledConfigFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::PathUtil + + # @return [DisabledConfigFormatter] a new instance of DisabledConfigFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:27 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:39 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:33 + def file_started(_file, _file_info); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:47 + def finished(_inspected_files); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:68 + def command; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:148 + def cop_config_params(default_cfg, cfg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:168 + def default_config(cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:207 + def excludes(offending_files, cop_name, parent); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:228 + def merge_mode_for_exclude?(cfg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:93 + def output_cop(cop_name, offense_count); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:120 + def output_cop_comments(output_buffer, cfg, cop_name, offense_count); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:172 + def output_cop_config(output_buffer, cfg, cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:155 + def output_cop_param_comments(output_buffer, params, default_cfg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:197 + def output_exclude_list(output_buffer, offending_files, cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:232 + def output_exclude_path(output_buffer, exclude_path, parent); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:186 + def output_offending_files(output_buffer, cfg, cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:87 + def output_offenses; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:245 + def safe_autocorrect?(config); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:107 + def set_max(cfg, cop_name); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:64 + def show_offense_counts?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:60 + def show_timestamp?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:140 + def supports_safe_autocorrect?(cop_class, default_cfg); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:144 + def supports_unsafe_autocorrect?(cop_class, default_cfg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:83 + def timestamp; end + + class << self + # Returns the value of attribute config_to_allow_offenses. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:24 + def config_to_allow_offenses; end + + # Sets the attribute config_to_allow_offenses + # + # @param value the value to set the attribute config_to_allow_offenses to. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:24 + def config_to_allow_offenses=(_arg0); end + + # Returns the value of attribute detected_styles. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:24 + def detected_styles; end + + # Sets the attribute detected_styles + # + # @param value the value to set the attribute detected_styles to. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:24 + def detected_styles=(_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/disabled_config_formatter.rb:10 +RuboCop::Formatter::DisabledConfigFormatter::HEADING = T.let(T.unsafe(nil), String) + +# This formatter displays the report data in format that's +# easy to process in the Emacs text editor. +# The output is machine-parsable. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/emacs_style_formatter.rb:8 +class RuboCop::Formatter::EmacsStyleFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/emacs_style_formatter.rb:9 + def file_finished(file, offenses); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/emacs_style_formatter.rb:24 + def message(offense); end +end + +# This formatter displays just a list of the files with offenses in them, +# separated by newlines. The output is machine-parsable. +# +# Here's the format: +# +# /some/file +# /some/other/file +# +# source://rubocop-1.35.1/lib/rubocop/formatter/file_list_formatter.rb:12 +class RuboCop::Formatter::FileListFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/file_list_formatter.rb:13 + def file_finished(file, offenses); end +end + +# This is a collection of formatters. A FormatterSet can hold multiple +# formatter instances and provides transparent formatter API methods +# which invoke same method of each formatters. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:10 +class RuboCop::Formatter::FormatterSet < ::Array + # @return [FormatterSet] a new instance of FormatterSet + # + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:39 + def initialize(options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:55 + def add_formatter(formatter_type, output_path = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:67 + def close_output_files; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:50 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:44 + def file_started(file, options); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:34 + def finished(*args); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:34 + def started(*args); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:86 + def builtin_formatter_class(specified_key); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:99 + def custom_formatter_class(specified_class_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:75 + def formatter_class(formatter_type); end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:11 +RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/formatter/formatter_set.rb:31 +RuboCop::Formatter::FormatterSet::FORMATTER_APIS = T.let(T.unsafe(nil), Array) + +# This formatter displays a progress bar and shows details of offenses as +# soon as they are detected. +# This is inspired by the Fuubar formatter for RSpec by Jeff Kreeftmeijer. +# https://github.com/jeffkreeftmeijer/fuubar +# +# source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:11 +class RuboCop::Formatter::FuubarStyleFormatter < ::RuboCop::Formatter::ClangStyleFormatter + # @return [FuubarStyleFormatter] a new instance of FuubarStyleFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:14 + def initialize(*output); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:51 + def count_stats(offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:40 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:71 + def progressbar_color; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:20 + def started(target_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:61 + def with_color; end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/fuubar_style_formatter.rb:12 +RuboCop::Formatter::FuubarStyleFormatter::RESET_SEQUENCE = T.let(T.unsafe(nil), String) + +# This formatter formats report data as GitHub Workflow commands resulting +# in GitHub check annotations when run within GitHub Actions. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:7 +class RuboCop::Formatter::GitHubActionsFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:14 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:18 + def finished(_inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:10 + def started(_target_files); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:29 + def github_escape(string); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:41 + def github_severity(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:33 + def minimum_severity_to_fail; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:45 + def report_offense(file, offense); end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/git_hub_actions_formatter.rb:8 +RuboCop::Formatter::GitHubActionsFormatter::ESCAPE_MAP = T.let(T.unsafe(nil), Hash) + +# This formatter saves the output as an html file. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:11 +class RuboCop::Formatter::HTMLFormatter < ::RuboCop::Formatter::BaseFormatter + # @return [HTMLFormatter] a new instance of HTMLFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:30 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:40 + def file_finished(file, offenses); end + + # Returns the value of attribute files. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:28 + def files; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:45 + def finished(inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:51 + def render_html; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:36 + def started(target_files); end + + # Returns the value of attribute summary. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:28 + def summary; end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:15 +class RuboCop::Formatter::HTMLFormatter::Color < ::Struct + # Returns the value of attribute alpha + # + # @return [Object] the current value of alpha + def alpha; end + + # Sets the attribute alpha + # + # @param value [Object] the value to set the attribute alpha to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:15 + def alpha=(_); end + + # Returns the value of attribute blue + # + # @return [Object] the current value of blue + def blue; end + + # Sets the attribute blue + # + # @param value [Object] the value to set the attribute blue to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:15 + def blue=(_); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:20 + def fade_out(amount); end + + # Returns the value of attribute green + # + # @return [Object] the current value of green + def green; end + + # Sets the attribute green + # + # @param value [Object] the value to set the attribute green to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:15 + def green=(_); end + + # Returns the value of attribute red + # + # @return [Object] the current value of red + def red; end + + # Sets the attribute red + # + # @param value [Object] the value to set the attribute red to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:15 + def red=(_); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:16 + def to_s; end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:12 +RuboCop::Formatter::HTMLFormatter::ELLIPSES = T.let(T.unsafe(nil), String) + +# This class provides helper methods used in the ERB template. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:62 +class RuboCop::Formatter::HTMLFormatter::ERBContext + include ::RuboCop::PathUtil + include ::RuboCop::Formatter::TextUtil + + # @return [ERBContext] a new instance of ERBContext + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:78 + def initialize(files, summary); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:125 + def base64_encoded_logo_image; end + + # Make Kernel#binding public. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:85 + def binding; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:90 + def decorated_message(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:121 + def escape(string); end + + # Returns the value of attribute files. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:76 + def files; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:101 + def highlight_source_tag(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:94 + def highlighted_source_line(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:117 + def possible_ellipses(location); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:112 + def source_after_highlight(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:107 + def source_before_highlight(offense); end + + # Returns the value of attribute summary. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:76 + def summary; end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:74 +RuboCop::Formatter::HTMLFormatter::ERBContext::LOGO_IMAGE_PATH = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:66 +RuboCop::Formatter::HTMLFormatter::ERBContext::SEVERITY_COLORS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:26 +class RuboCop::Formatter::HTMLFormatter::FileOffenses < ::Struct + # Returns the value of attribute offenses + # + # @return [Object] the current value of offenses + def offenses; end + + # Sets the attribute offenses + # + # @param value [Object] the value to set the attribute offenses to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:26 + def offenses=(_); end + + # Returns the value of attribute path + # + # @return [Object] the current value of path + def path; end + + # Sets the attribute path + # + # @param value [Object] the value to set the attribute path to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:26 + def path=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:25 +class RuboCop::Formatter::HTMLFormatter::Summary < ::Struct + # Returns the value of attribute inspected_files + # + # @return [Object] the current value of inspected_files + def inspected_files; end + + # Sets the attribute inspected_files + # + # @param value [Object] the value to set the attribute inspected_files to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:25 + def inspected_files=(_); end + + # Returns the value of attribute offense_count + # + # @return [Object] the current value of offense_count + def offense_count; end + + # Sets the attribute offense_count + # + # @param value [Object] the value to set the attribute offense_count to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:25 + def offense_count=(_); end + + # Returns the value of attribute target_files + # + # @return [Object] the current value of target_files + def target_files; end + + # Sets the attribute target_files + # + # @param value [Object] the value to set the attribute target_files to. + # @return [Object] the newly set value + # + # source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:25 + def target_files=(_); end + + class << self + def [](*_arg0); end + def inspect; end + def members; end + def new(*_arg0); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/html_formatter.rb:13 +RuboCop::Formatter::HTMLFormatter::TEMPLATE_PATH = T.let(T.unsafe(nil), String) + +# This formatter formats the report data in JSON format. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:9 +class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::PathUtil + + # @return [JSONFormatter] a new instance of JSONFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:14 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:23 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:28 + def finished(inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:43 + def hash_for_file(file, offenses); end + + # TODO: Consider better solution for Offense#real_column. + # The minimum value of `start_column: real_column` is 1. + # So, the minimum value of `last_column` should be 1. + # And non-zero value of `last_column` should be used as is. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:65 + def hash_for_location(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:50 + def hash_for_offense(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:33 + def metadata_hash; end + + # Returns the value of attribute output_hash. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:12 + def output_hash; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/json_formatter.rb:19 + def started(target_files); end +end + +# This formatter formats the report data in JUnit format. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:17 +class RuboCop::Formatter::JUnitFormatter < ::RuboCop::Formatter::BaseFormatter + # @return [JUnitFormatter] a new instance of JUnitFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:18 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:55 + def add_testcase_element_to_testsuite_element(file, target_offenses, cop); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:64 + def classname_attribute_value(file); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:29 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:68 + def finished(_inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:51 + def offenses_for_cop(all_offenses, cop); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:47 + def relevant_for_output?(options, target_offenses); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:80 + def add_failure_to(testcase, offenses, cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/junit_formatter.rb:75 + def reset_count; end +end + +# This formatter displays the report data in markdown +# +# source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:6 +class RuboCop::Formatter::MarkdownFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::Formatter::TextUtil + include ::RuboCop::PathUtil + + # @return [MarkdownFormatter] a new instance of MarkdownFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:11 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:21 + def file_finished(file, offenses); end + + # Returns the value of attribute files. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:9 + def files; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:26 + def finished(inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:17 + def started(target_files); end + + # Returns the value of attribute summary. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:9 + def summary; end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:73 + def possible_ellipses(location); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:33 + def render_markdown; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:67 + def write_code(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:61 + def write_context(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:42 + def write_file_messages; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/markdown_formatter.rb:54 + def write_heading(file); end +end + +# This formatter displays the list of offended cops with a count of how +# many offenses of their kind were found. Ordered by desc offense count +# +# Here's the format: +# +# 26 LineLength +# 3 OneLineConditional +# -- +# 29 Total +# +# source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:16 +class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:41 + def file_finished(_file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:49 + def finished(_inspected_files); end + + # Returns the value of attribute offense_counts. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:17 + def offense_counts; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:71 + def ordered_offense_counts(offense_counts); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:54 + def report_summary(offense_counts); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:19 + def started(target_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/offense_count_formatter.rb:75 + def total_offense_count(offense_counts); end +end + +# This formatter prints a PACDOT per every file to be analyzed. +# Pacman will "eat" one PACDOT per file when no offense is detected. +# Otherwise it will print a Ghost. +# This is inspired by the Pacman formatter for RSpec by Carlos Rojas. +# https://github.com/go-labs/rspec_pacman_formatter +# +# source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:10 +class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include ::RuboCop::Formatter::TextUtil + + # @return [PacmanFormatter] a new instance of PacmanFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:19 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:50 + def cols; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:37 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:33 + def file_started(_file, _options); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:43 + def next_step(offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:64 + def pacdots(number); end + + # Returns the value of attribute progress_line. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:12 + def progress_line; end + + # Sets the attribute progress_line + # + # @param value the value to set the attribute progress_line to. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:12 + def progress_line=(_arg0); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:26 + def started(target_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:68 + def step(character); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:57 + def update_progress_line; end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:14 +RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) + +# source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:15 +RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:17 +RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter) + +# source://rubocop-1.35.1/lib/rubocop/formatter/pacman_formatter.rb:16 +RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter) + +# This formatter display dots for files with no offenses and +# letters for files with problems in the them. In the end it +# appends the regular report data in the clang style format. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:8 +class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter + include ::RuboCop::Formatter::TextUtil + + # @return [ProgressFormatter] a new instance of ProgressFormatter + # + # source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:13 + def initialize(output, options = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:24 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:33 + def finished(inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:50 + def report_file_as_mark(offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:18 + def started(target_files); end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/progress_formatter.rb:11 +RuboCop::Formatter::ProgressFormatter::DOT = T.let(T.unsafe(nil), String) + +# If no offenses are found, no output is displayed. +# Otherwise, SimpleTextFormatter's output is displayed. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/quiet_formatter.rb:7 +class RuboCop::Formatter::QuietFormatter < ::RuboCop::Formatter::SimpleTextFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/quiet_formatter.rb:8 + def report_summary(file_count, offense_count, correction_count, correctable_count); end +end + +# A basic formatter that displays only files with offenses. +# Offenses are displayed at compact form - just the +# location of the problem and the associated message. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:10 +class RuboCop::Formatter::SimpleTextFormatter < ::RuboCop::Formatter::BaseFormatter + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::PathUtil + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:29 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:36 + def finished(inspected_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:43 + def report_file(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:57 + def report_summary(file_count, offense_count, correction_count, correctable_count); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:23 + def started(_target_files); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:85 + def annotate_message(msg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:80 + def colored_severity_code(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:73 + def count_stats(offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:89 + def message(offense); end +end + +# source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:14 +RuboCop::Formatter::SimpleTextFormatter::COLOR_FOR_SEVERITY = T.let(T.unsafe(nil), Hash) + +# A helper class for building the report summary text. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:105 +class RuboCop::Formatter::SimpleTextFormatter::Report + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::Formatter::TextUtil + + # @return [Report] a new instance of Report + # + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:110 + def initialize(file_count, offense_count, correction_count, correctable_count, rainbow, safe_autocorrect: T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:123 + def summary; end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:160 + def correctable; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:153 + def corrections; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:142 + def files; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:146 + def offenses; end + + # Returns the value of attribute rainbow. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/simple_text_formatter.rb:140 + def rainbow; end +end + +# This formatter formats report data using the Test Anything Protocol. +# TAP allows for to communicate tests results in a language agnostics way. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:7 +class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:14 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:8 + def started(target_files); end + + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:66 + def annotate_message(msg); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:70 + def message(offense); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:39 + def report_highlighted_area(highlighted_area); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:29 + def report_line(location); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/tap_formatter.rb:46 + def report_offense(file, offense); end +end + +# Common logic for UI texts. +# +# source://rubocop-1.35.1/lib/rubocop/formatter/text_util.rb:6 +module RuboCop::Formatter::TextUtil + private + + # source://rubocop-1.35.1/lib/rubocop/formatter/text_util.rb:9 + def pluralize(number, thing, options = T.unsafe(nil)); end + + class << self + # source://rubocop-1.35.1/lib/rubocop/formatter/text_util.rb:9 + def pluralize(number, thing, options = T.unsafe(nil)); end + end +end + +# This formatter displays the list of offensive files, sorted by number of +# offenses with the worst offenders first. +# +# Here's the format: +# +# 26 this/file/is/really/bad.rb +# 3 just/ok.rb +# -- +# 29 Total +# +# source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:16 +class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:24 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:31 + def finished(_inspected_files); end + + # Returns the value of attribute offense_counts. + # + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:17 + def offense_counts; end + + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:52 + def ordered_offense_counts(offense_counts); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:36 + def report_summary(offense_counts); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:19 + def started(target_files); end + + # source://rubocop-1.35.1/lib/rubocop/formatter/worst_offenders_formatter.rb:56 + def total_offense_count(offense_counts); end +end + +# source://rubocop-1.35.1/lib/rubocop/options.rb:7 +class RuboCop::IncorrectCopNameError < ::StandardError; end + +# Encapsulation of a lockfile for use when checking for gems. +# Does not actually resolve gems, just parses the lockfile. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/lockfile.rb:7 +class RuboCop::Lockfile + # Gems that the bundle depends on + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/lockfile.rb:9 + def dependencies; end + + # All activated gems, including transitive dependencies + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/lockfile.rb:16 + def gems; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/lockfile.rb:24 + def includes_gem?(name); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/lockfile.rb:30 + def parser; end +end + +# Parse different formats of magic comments. +# +# @abstract parent of three different magic comment handlers +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:7 +class RuboCop::MagicComment + # @return [MagicComment] a new instance of MagicComment + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:32 + def initialize(comment); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:36 + def any?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:104 + def encoding_specified?; end + + # Expose the `frozen_string_literal` value coerced to a boolean if possible. + # + # @return [Boolean] if value is `true` or `false` + # @return [nil] if frozen_string_literal comment isn't found + # @return [String] if comment is found but isn't true or false + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:86 + def frozen_string_literal; end + + # Does the magic comment enable the frozen string literal feature. + # + # Test whether the frozen string literal value is `true`. Cannot + # just return `frozen_string_literal` since an invalid magic comment + # `'yes'` does not actually enable the feature + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:55 + def frozen_string_literal?; end + + # Was a magic comment for the frozen string literal found? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:70 + def frozen_string_literal_specified?; end + + # Expose the `shareable_constant_value` value coerced to a boolean if possible. + # + # @return [String] for shareable_constant_value config + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:100 + def shareable_constant_value; end + + # Was a shareable_constant_value specified? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:77 + def shareable_constant_value_specified?; end + + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:115 + def typed; end + + # Was the Sorbet `typed` sigil specified? + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:111 + def typed_specified?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:43 + def valid?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:59 + def valid_literal_value?; end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:63 + def valid_shareable_constant_value?; end + + private + + # Match the entire comment string with a pattern and take the first capture. + # + # @param pattern [Regexp] + # @return [String] if pattern matched + # @return [nil] otherwise + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:131 + def extract(pattern); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:121 + def specified?(value); end + + class << self + # Detect magic comment format and pass it to the appropriate wrapper. + # + # @param comment [String] + # @return [RuboCop::MagicComment] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:23 + def parse(comment); end + end +end + +# Parent to Vim and Emacs magic comment handling. +# +# @abstract +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:138 +class RuboCop::MagicComment::EditorComment < ::RuboCop::MagicComment + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:139 + def encoding; end + + # Rewrite the comment without a given token type + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:144 + def without(type); end + + private + + # Find a token starting with the provided keyword and extract its value. + # + # @param keyword [String] + # @return [String] extracted value if it is found + # @return [nil] otherwise + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:159 + def match(keyword); end + + # Individual tokens composing an editor specific comment string. + # + # @return [Array<String>] + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:174 + def tokens; end +end + +# Wrapper for Emacs style magic comments. +# +# @example Emacs style comment +# comment = RuboCop::MagicComment.parse( +# '# -*- encoding: ASCII-8BIT -*-' +# ) +# +# comment.encoding # => 'ascii-8bit' +# @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html +# @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:190 +class RuboCop::MagicComment::EmacsComment < ::RuboCop::MagicComment::EditorComment + private + + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:198 + def extract_frozen_string_literal; end + + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:202 + def extract_shareable_constant_value; end + + # Emacs comments cannot specify Sorbet typechecking behavior. + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:207 + def extract_typed; end +end + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:192 +RuboCop::MagicComment::EmacsComment::FORMAT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:194 +RuboCop::MagicComment::EmacsComment::OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:191 +RuboCop::MagicComment::EmacsComment::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:193 +RuboCop::MagicComment::EmacsComment::SEPARATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:11 +RuboCop::MagicComment::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# Wrapper for regular magic comments not bound to an editor. +# +# Simple comments can only specify one setting per comment. +# +# @example frozen string literal comments +# comment1 = RuboCop::MagicComment.parse('# frozen_string_literal: true') +# comment1.frozen_string_literal # => true +# comment1.encoding # => nil +# @example encoding comments +# comment2 = RuboCop::MagicComment.parse('# encoding: utf-8') +# comment2.frozen_string_literal # => nil +# comment2.encoding # => 'utf-8' +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:262 +class RuboCop::MagicComment::SimpleComment < ::RuboCop::MagicComment + # Match `encoding` or `coding` + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:263 + def encoding; end + + # Rewrite the comment without a given token type + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:268 + def without(type); end + + private + + # Extract `frozen_string_literal`. + # + # The `frozen_string_literal` magic comment only works if it + # is the only text in the comment. + # + # Case-insensitive and dashes/underscores are acceptable. + # + # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138 + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:285 + def extract_frozen_string_literal; end + + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:289 + def extract_shareable_constant_value; end + + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:293 + def extract_typed; end +end + +# IRB's pattern for matching magic comment tokens. +# +# @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5 +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:10 +RuboCop::MagicComment::TOKEN = T.let(T.unsafe(nil), Regexp) + +# Wrapper for Vim style magic comments. +# +# @example Vim style comment +# comment = RuboCop::MagicComment.parse( +# '# vim: filetype=ruby, fileencoding=ascii-8bit' +# ) +# +# comment.encoding # => 'ascii-8bit' +# +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:218 +class RuboCop::MagicComment::VimComment < ::RuboCop::MagicComment::EditorComment + # For some reason the fileencoding keyword only works if there + # is at least one other token included in the string. For example + # + # # works + # # vim: foo=bar, fileencoding=ascii-8bit + # + # # does nothing + # # vim: foo=bar, fileencoding=ascii-8bit + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:234 + def encoding; end + + # Vim comments cannot specify Sorbet typechecking behavior. + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:245 + def extract_typed; end + + # Vim comments cannot specify frozen string literal behavior. + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:239 + def frozen_string_literal; end + + # Vim comments cannot specify shareable constant values behavior. + # + # source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:242 + def shareable_constant_value; end +end + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:220 +RuboCop::MagicComment::VimComment::FORMAT = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:223 +RuboCop::MagicComment::VimComment::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:222 +RuboCop::MagicComment::VimComment::OPERATOR = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:219 +RuboCop::MagicComment::VimComment::REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/magic_comment.rb:221 +RuboCop::MagicComment::VimComment::SEPARATOR = T.let(T.unsafe(nil), String) + +# Common functionality for finding names that are similar to a given name. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/name_similarity.rb:6 +module RuboCop::NameSimilarity + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/name_similarity.rb:9 + def find_similar_name(target_name, names); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/name_similarity.rb:15 + def find_similar_names(target_name, names); end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/name_similarity.rb:9 + def find_similar_name(target_name, names); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/name_similarity.rb:15 + def find_similar_names(target_name, names); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:5 +RuboCop::NodePattern = RuboCop::AST::NodePattern + +# source://rubocop-1.35.1/lib/rubocop/options.rb:9 +class RuboCop::OptionArgumentError < ::StandardError; end + +# This class handles command line options. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:13 +class RuboCop::Options + # @api private + # @return [Options] a new instance of Options + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:21 + def initialize; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:26 + def parse(command_line_args); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:217 + def add_additional_modes(opts); end + + # the autocorrect command-line arguments map to the autocorrect @options values like so: + # :fix_layout :autocorrect :safe_autocorrect :autocorrect_all + # -x, --fix-layout true true - - + # -a, --auto-correct - true true - + # --safe-auto-correct - true true - + # -A, --auto-correct-all - true - true + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:140 + def add_autocorrection_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:200 + def add_cache_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:75 + def add_check_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:163 + def add_config_generation_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:179 + def add_cop_selection_csv_option(option, opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:229 + def add_general_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:105 + def add_output_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:207 + def add_server_options(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:191 + def add_severity_option(opts); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:56 + def args_from_env; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:48 + def args_from_file; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:60 + def define_options; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:241 + def handle_deprecated_option(old_option, new_option); end + + # Finds the option in `args` starting with -- and converts it to a symbol, + # e.g. [..., '--autocorrect', ...] to :autocorrect. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:275 + def long_opt_symbol(args); end + + # Sets a value in the @options hash, based on the given long option and its + # value, in addition to calling the block if a block is given. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:264 + def option(opts, *args); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:246 + def rainbow; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:280 + def require_feature(file); end + + # Creates a section of options in order to separate them visually when + # using `--help`. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:256 + def section(opts, heading, &_block); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:19 +RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS = T.let(T.unsafe(nil), Integer) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:18 +RuboCop::Options::EXITING_OPTIONS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:14 +RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String) + +# This module contains help texts for command line options. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:467 +module RuboCop::OptionsHelp; end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:469 +RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:468 +RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:471 +RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash) + +# Validates option arguments and the options' compatibility with each other. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/options.rb:290 +class RuboCop::OptionsValidator + # @api private + # @return [OptionsValidator] a new instance of OptionsValidator + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:328 + def initialize(options); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:442 + def boolean_or_empty_cache?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:410 + def disable_parallel_when_invalid_option_combo; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:434 + def display_only_fail_level_offenses_with_autocorrect?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:438 + def except_syntax?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:446 + def incompatible_options; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:423 + def invalid_arguments_for_parallel; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:429 + def only_includes_redundant_disable?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:363 + def validate_auto_gen_config; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:402 + def validate_autocorrect; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:458 + def validate_cache_enabled_for_cache_root; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:337 + def validate_compatibility; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:332 + def validate_cop_options; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:384 + def validate_display_only_correctable_and_autocorrect; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:376 + def validate_display_only_failed; end + + # @api private + # @raise [OptionArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:393 + def validate_display_only_failed_and_display_only_correctable; end + + # @api private + # @raise [OptionParser::MissingArgument] + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:450 + def validate_exclude_limit_option; end + + class << self + # Cop name validation must be done later than option parsing, so it's not + # called from within Options. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:297 + def validate_cop_list(names); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/options.rb:314 + def format_message_from(name, cop_names); end + end +end + +# Common methods and behaviors for dealing with paths. +# +# source://rubocop-1.35.1/lib/rubocop/path_util.rb:5 +module RuboCop::PathUtil + private + + # Returns true for an absolute Unix or Windows path. + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:53 + def absolute?(path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:79 + def hidden_dir?(path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:66 + def hidden_file?(path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:57 + def hidden_file_in_not_hidden_dir?(pattern, path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:36 + def match_path?(pattern, path); end + + # Loose check to reduce memory allocations + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:71 + def maybe_hidden_file?(path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:8 + def relative_path(path, base_dir = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:25 + def smart_path(path); end + + class << self + # Returns true for an absolute Unix or Windows path. + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:53 + def absolute?(path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:79 + def hidden_dir?(path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:66 + def hidden_file?(path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:57 + def hidden_file_in_not_hidden_dir?(pattern, path); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:36 + def match_path?(pattern, path); end + + # Loose check to reduce memory allocations + # + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:71 + def maybe_hidden_file?(path); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:8 + def relative_path(path, base_dir = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/path_util.rb:25 + def smart_path(path); end + end +end + +# This module provides information on the platform that RuboCop is being run +# on. +# +# source://rubocop-1.35.1/lib/rubocop/platform.rb:6 +module RuboCop::Platform + class << self + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/platform.rb:7 + def windows?; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:6 +RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource + +# Provides a custom rake task. +# +# require 'rubocop/rake_task' +# RuboCop::RakeTask.new +# +# Use global Rake namespace here to avoid namespace issues with custom +# rubocop-rake tasks +# +# source://rubocop-1.33.0/lib/rubocop/rake_task.rb:14 +class RuboCop::RakeTask < ::Rake::TaskLib + # @return [RakeTask] a new instance of RakeTask + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:17 + def initialize(name = T.unsafe(nil), *args, &task_block); end + + # Returns the value of attribute fail_on_error. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def fail_on_error; end + + # Sets the attribute fail_on_error + # + # @param value the value to set the attribute fail_on_error to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def fail_on_error=(_arg0); end + + # Returns the value of attribute formatters. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def formatters; end + + # Sets the attribute formatters + # + # @param value the value to set the attribute formatters to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def formatters=(_arg0); end + + # Returns the value of attribute name. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def name; end + + # Sets the attribute name + # + # @param value the value to set the attribute name to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def name=(_arg0); end + + # Returns the value of attribute options. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def options; end + + # Sets the attribute options + # + # @param value the value to set the attribute options to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def options=(_arg0); end + + # Returns the value of attribute patterns. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def patterns; end + + # Sets the attribute patterns + # + # @param value the value to set the attribute patterns to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def patterns=(_arg0); end + + # Returns the value of attribute requires. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def requires; end + + # Sets the attribute requires + # + # @param value the value to set the attribute requires to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def requires=(_arg0); end + + # Returns the value of attribute verbose. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def verbose; end + + # Sets the attribute verbose + # + # @param value the value to set the attribute verbose to. + # + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:15 + def verbose=(_arg0); end + + private + + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:55 + def full_options; end + + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:35 + def perform(option); end + + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:44 + def run_cli(verbose, options); end + + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:62 + def setup_ivars(name); end + + # source://rubocop-1.33.0/lib/rubocop/rake_task.rb:72 + def setup_subtasks(name, *args, &task_block); end +end + +# Common methods and behaviors for dealing with remote config files. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/remote_config.rb:9 +class RuboCop::RemoteConfig + # @api private + # @return [RemoteConfig] a new instance of RemoteConfig + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:14 + def initialize(url, base_dir); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:19 + def file; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:32 + def inherit_from_remote(file, path); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:10 + def uri; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:95 + def cache_name_from_uri; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:78 + def cache_path; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:82 + def cache_path_exists?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:86 + def cache_path_expired?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:101 + def cloned_url; end + + # @api private + # @yield [request] + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:53 + def generate_request(uri); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:62 + def handle_response(response, limit, &block); end + + # @api private + # @raise [ArgumentError] + # + # source://rubocop-1.35.1/lib/rubocop/remote_config.rb:40 + def request(uri = T.unsafe(nil), limit = T.unsafe(nil), &block); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/remote_config.rb:12 +RuboCop::RemoteConfig::CACHE_LIFETIME = T.let(T.unsafe(nil), Integer) + +# Provides functionality for caching RuboCop runs. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/result_cache.rb:12 +class RuboCop::ResultCache + # @api private + # @return [ResultCache] a new instance of ResultCache + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:88 + def initialize(file, team, options, config_store, cache_root = T.unsafe(nil)); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:101 + def debug?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:109 + def load; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:86 + def path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:114 + def save(offenses); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:105 + def valid?; end + + private + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:147 + def any_symlink?(path); end + + # We combine team and options into a single "context" checksum to avoid + # making file names that are too long for some filesystems to handle. + # This context is for anything that's not (1) the RuboCop executable + # checksum or (2) the inspected file checksum. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:233 + def context_checksum(team, options); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:190 + def digest(path); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:158 + def file_checksum(file, config_store); end + + # Return a hash of the options given at invocation, minus the ones that have + # no effect on which offenses and disabled line ranges are found, and thus + # don't affect caching. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:217 + def relevant_options_digest(options); end + + # The checksum of the RuboCop program running the inspection. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:175 + def rubocop_checksum; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:201 + def rubocop_extra_features; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:143 + def symlink_protection_triggered?(path); end + + # The external dependency checksums are cached per RuboCop team so that + # the checksums don't need to be recomputed for each file. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:224 + def team_checksum(team); end + + class << self + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:82 + def allow_symlinks_in_cache_location?(config_store); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:76 + def cache_root(config_store); end + + # Remove old files so that the cache doesn't grow too big. When the + # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the + # files in the cache are removed. The reason for removing so much is that + # cleaning should be done relatively seldom, since there is a slight risk + # that some other RuboCop process was just about to read the file, when + # there's parallel execution and the cache is shared. + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:29 + def cleanup(config_store, verbose, cache_root = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:171 + def inhibit_cleanup; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:171 + def inhibit_cleanup=(_arg0); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:43 + def rubocop_required_features; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:43 + def rubocop_required_features=(_arg0); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:171 + def source_checksum; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:171 + def source_checksum=(_arg0); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:66 + def remove_files(files, dirs, remove_count); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:53 + def remove_oldest_files(files, dirs, cache_root, verbose); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/result_cache.rb:49 + def requires_file_removal?(file_count, config_store); end + end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/result_cache.rb:17 +RuboCop::ResultCache::DL_EXTENSIONS = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/result_cache.rb:13 +RuboCop::ResultCache::NON_CHANGING = T.let(T.unsafe(nil), Array) + +# This class handles the processing of files, which includes dealing with +# formatters and letting cops inspect the files. +# +# source://rubocop-1.35.1/lib/rubocop/runner.rb:8 +class RuboCop::Runner + # @return [Runner] a new instance of Runner + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:33 + def initialize(options, config_store); end + + # Sets the attribute aborting + # + # @param value the value to set the attribute aborting to. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:31 + def aborting=(_arg0); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:57 + def aborting?; end + + # Returns the value of attribute errors. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:30 + def errors; end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:41 + def run(paths); end + + # Returns the value of attribute warnings. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:30 + def warnings; end + + private + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:166 + def add_redundant_disables(file, offenses, source); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:140 + def cached_result(file, team); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:218 + def cached_run?; end + + # Check whether a run created source identical to a previous run, which + # means that we definitely have an infinite loop. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:296 + def check_for_infinite_loop(processed_source, offenses_by_iteration); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:192 + def check_for_redundant_disables?(source); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:376 + def considered_failure?(offense); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:409 + def default_config(cop_name); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:240 + def do_inspection_loop(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:103 + def each_inspected_file(files); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:213 + def file_finished(file, offenses); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:144 + def file_offense_cache(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:132 + def file_offenses(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:208 + def file_started(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:356 + def filter_cop_classes(cop_classes, config); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:204 + def filtered_run?; end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:74 + def find_target_files(paths); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:367 + def formatter_set; end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:421 + def get_processed_source(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:310 + def inspect_file(processed_source, team = T.unsafe(nil)); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:85 + def inspect_files(files); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:271 + def iterate_until_no_changes(source, offenses_by_iteration); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:118 + def list_files(paths); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:405 + def mark_as_safe_by_config?(config); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:413 + def minimum_severity_to_fail; end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:317 + def mobilize_team(processed_source); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:322 + def mobilized_cop_classes(config); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:385 + def offenses_to_report(offenses); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:122 + def process_file(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:346 + def qualify_option_cop_names; end + + # @yield [cop] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:196 + def redundant_cop_disable_directive(file); end + + # source://rubocop-1.35.1/lib/rubocop/runner.rb:230 + def save_in_cache(cache, offenses); end + + # A Cop::Team instance is stateful and may change when inspecting. + # The "standby" team for a given config is an initialized but + # otherwise dormant team that can be used for config- and option- + # level caching in ResultCache. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:439 + def standby_team(config); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:363 + def style_guide_cops_only?(config); end + + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:397 + def supports_safe_autocorrect?(offense); end + + # @yield [team] + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:181 + def team_for_redundant_disables(file, offenses, source); end + + # Warms up the RuboCop cache by forking a suitable number of RuboCop + # instances that each inspects its allotted group of files. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:65 + def warm_cache(target_files); end +end + +# An exception indicating that the inspection loop got stuck correcting +# offenses back and forth. +# +# source://rubocop-1.35.1/lib/rubocop/runner.rb:11 +class RuboCop::Runner::InfiniteCorrectionLoop < ::StandardError + # @return [InfiniteCorrectionLoop] a new instance of InfiniteCorrectionLoop + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:14 + def initialize(path, offenses_by_iteration, loop_start: T.unsafe(nil)); end + + # Returns the value of attribute offenses. + # + # source://rubocop-1.35.1/lib/rubocop/runner.rb:12 + def offenses; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/runner.rb:28 +RuboCop::Runner::MAX_ITERATIONS = T.let(T.unsafe(nil), Integer) + +# Take a string with embedded escapes, and convert the escapes as the Ruby +# interpreter would when reading a double-quoted string literal. +# For example, "\\n" will be converted to "\n". +# +# source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:7 +class RuboCop::StringInterpreter + class << self + # source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:24 + def interpret(string); end + + private + + # source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:51 + def interpret_hex(escape); end + + # source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:55 + def interpret_octal(escape); end + + # source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:33 + def interpret_string_escape(escape); end + + # source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:43 + def interpret_unicode(escape); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:8 +RuboCop::StringInterpreter::STRING_ESCAPES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/string_interpreter.rb:12 +RuboCop::StringInterpreter::STRING_ESCAPE_REGEX = T.let(T.unsafe(nil), Regexp) + +# This class finds target files to inspect by scanning the directory tree +# and picking ruby files. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_finder.rb:7 +class RuboCop::TargetFinder + # @api private + # @return [TargetFinder] a new instance of TargetFinder + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:10 + def initialize(config_store, options = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:145 + def all_cops_include; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:116 + def combined_exclude_glob_patterns(base_dir); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:172 + def configured_include?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:19 + def debug?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:23 + def fail_fast?; end + + # Generate a list of target files by expanding globbing patterns + # (if any). If args is empty, recursively find all Ruby source + # files under the current directory + # + # @api private + # @return [Array] array of file paths + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:31 + def find(args, mode); end + + # Search for files recursively starting at the given base directory using + # the given flags that determine how the match is made. Excluded files will + # be removed later by the caller, but as an optimization find_files removes + # the top level directories that are excluded in configuration in the + # normal way (dir/**/*). + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:83 + def find_files(base_dir, flags); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:15 + def force_exclusion?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:176 + def included_file?(file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:180 + def process_explicit_path(path, mode); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:149 + def ruby_executable?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:123 + def ruby_extension?(file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:127 + def ruby_extensions; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:168 + def ruby_file?(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:134 + def ruby_filename?(file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:138 + def ruby_filenames; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:160 + def ruby_interpreters(file); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:164 + def stdin?; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:108 + def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags); end + + # Finds all Ruby source files under the current or other supplied + # directory. A Ruby source file is defined as a file with the `.rb` + # extension or a file with no extension that has a ruby shebang line + # as its first line. + # It is possible to specify includes and excludes using the config file, + # so you can include other Ruby files like Rakefiles and gemspecs. + # + # @api private + # @param base_dir Root directory under which to search for + # ruby source files + # @return [Array] Array of filenames + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:56 + def target_files_in_dir(base_dir = T.unsafe(nil)); end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:69 + def to_inspect?(file, hidden_files, base_dir_config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:96 + def wanted_dir_patterns(base_dir, exclude_pattern, flags); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_finder.rb:197 + def order; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_finder.rb:8 +RuboCop::TargetFinder::HIDDEN_PATH_SUBSTRING = T.let(T.unsafe(nil), String) + +# The kind of Ruby that code inspected by RuboCop is written in. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:6 +class RuboCop::TargetRuby + # @api private + # @return [TargetRuby] a new instance of TargetRuby + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:248 + def initialize(config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:264 + def rubocop_version_with_support; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:252 + def source; end + + # @api private + # @return [Boolean] + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:260 + def supported?; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:256 + def version; end + + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:233 + def supported_versions; end + end +end + +# The lock file of Bundler may identify the target ruby version. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:106 +class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:107 + def name; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:140 + def bundler_lock_file_path; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:113 + def find_version; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:8 +RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float) + +# If all else fails, a default version will be picked. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:221 +class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:222 + def name; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:228 + def find_version; end +end + +# The target ruby version may be found in a .gemspec file. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:147 +class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source + extend ::RuboCop::AST::NodePattern::Macros + + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:158 + def gem_requirement?(param0 = T.unsafe(nil)); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:162 + def name; end + + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:153 + def required_ruby_version(param0); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:209 + def find_default_minimal_known_ruby(right_hand_side); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:168 + def find_version; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:178 + def gemspec_filename; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:185 + def gemspec_filepath; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:205 + def version_from_array(array); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:190 + def version_from_gemspec_file(file); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:195 + def version_from_right_hand_side(right_hand_side); end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:150 +RuboCop::TargetRuby::GemspecFile::GEMSPEC_EXTENSION = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:7 +RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:10 +RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash) + +# The target ruby version may be configured in RuboCop's config. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:38 +class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:39 + def name; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:45 + def find_version; end +end + +# The target ruby version may be found in a .ruby-version file. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:52 +class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:56 + def name; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:62 + def filename; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:70 + def find_version; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:66 + def pattern; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:77 + def version_file; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:53 +RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:54 +RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:237 +RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array) + +# A place where information about a target ruby version is found. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:23 +class RuboCop::TargetRuby::Source + # @api private + # @return [Source] a new instance of Source + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:26 + def initialize(config); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:24 + def name; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:31 + def to_s; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:24 + def version; end +end + +# The target ruby version may be found in a .tool-versions file, in a line +# starting with `ruby`. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:85 +class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:89 + def name; end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:95 + def filename; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:99 + def pattern; end +end + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:86 +RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String) + +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/target_ruby.rb:87 +RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://rubocop-1.35.1/lib/rubocop/ast_aliases.rb:7 +RuboCop::Token = RuboCop::AST::Token + +# This module contains a collection of useful utility methods. +# +# source://rubocop-1.35.1/lib/rubocop/util.rb:5 +module RuboCop::Util + class << self + # source://rubocop-1.35.1/lib/rubocop/util.rb:6 + def silence_warnings; end + end +end + +# source://rubocop-1.35.1/lib/rubocop/error.rb:10 +class RuboCop::ValidationError < ::RuboCop::Error; end + +# This module holds the RuboCop version information. +# +# source://rubocop-1.35.1/lib/rubocop/version.rb:5 +module RuboCop::Version + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/version.rb:88 + def document_version; end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/version.rb:38 + def extension_versions(env); end + + # Returns feature version in one of two ways: + # + # * Find by RuboCop core version style (e.g. rubocop-performance, rubocop-rspec) + # * Find by `bundle gem` version style (e.g. rubocop-rake) + # + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/version.rb:72 + def feature_version(feature); end + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/version.rb:17 + def version(debug: T.unsafe(nil), env: T.unsafe(nil)); end + end +end + +# source://rubocop-1.35.1/lib/rubocop/version.rb:12 +RuboCop::Version::CANONICAL_FEATURE_NAMES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/version.rb:14 +RuboCop::Version::EXTENSION_PATH_NAMES = T.let(T.unsafe(nil), Hash) + +# source://rubocop-1.35.1/lib/rubocop/version.rb:8 +RuboCop::Version::MSG = T.let(T.unsafe(nil), String) + +# source://rubocop-1.35.1/lib/rubocop/version.rb:6 +RuboCop::Version::STRING = T.let(T.unsafe(nil), String) + +# A Warning exception is different from an Offense with severity 'warning' +# When a Warning is raised, this means that RuboCop was unable to perform a +# requested operation (such as inspecting or correcting a source file) due to +# user error +# For example, a configuration value in .rubocop.yml might be malformed +# +# source://rubocop-1.35.1/lib/rubocop/warning.rb:9 +class RuboCop::Warning < ::StandardError; end + +# Find duplicated keys from YAML. +# +# @api private +# +# source://rubocop-1.35.1/lib/rubocop/yaml_duplication_checker.rb:6 +module RuboCop::YAMLDuplicationChecker + class << self + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/yaml_duplication_checker.rb:7 + def check(yaml_string, filename, &on_duplicated); end + + private + + # @api private + # + # source://rubocop-1.35.1/lib/rubocop/yaml_duplication_checker.rb:21 + def traverse(tree, &on_duplicated); end + end +end + +# Extensions to the core String class +# +# source://rubocop-1.35.1/lib/rubocop/core_ext/string.rb:4 +class String + include ::Comparable + + # Checks whether a string is blank. A string is considered blank if it + # is either empty or contains only whitespace characters. + # + # @example + # ''.blank? #=> true + # @example + # ' '.blank? #=> true + # @example + # ' test'.blank? #=> false + # @return [Boolean] true is the string is blank, false otherwise + # + # source://rubocop-1.35.1/lib/rubocop/core_ext/string.rb:19 + def blank?; end +end diff --git a/sorbet/rbi/gems/ruby-progressbar.rbi b/sorbet/rbi/gems/ruby-progressbar.rbi deleted file mode 100644 index 81b23356..00000000 --- a/sorbet/rbi/gems/ruby-progressbar.rbi +++ /dev/null @@ -1,304 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ruby-progressbar/all/ruby-progressbar.rbi -# -# ruby-progressbar-1.11.0 - -class ProgressBar - def self.create(*args); end -end -class ProgressBar::Output - def bar; end - def bar=(arg0); end - def clear_string; end - def initialize(options = nil); end - def length; end - def length_calculator; end - def length_calculator=(arg0); end - def log(string); end - def print_and_flush; end - def refresh(options = nil); end - def self.detect(options = nil); end - def stream; end - def stream=(arg0); end - def throttle; end - def throttle=(arg0); end - def with_refresh; end -end -module ProgressBar::Outputs -end -class ProgressBar::Outputs::Tty < ProgressBar::Output - def bar_update_string; end - def clear; end - def default_format; end - def eol; end - def refresh_with_format_change; end - def resolve_format(other_format); end -end -class ProgressBar::Outputs::NonTty < ProgressBar::Output - def bar_update_string; end - def clear; end - def default_format; end - def eol; end - def last_update_length; end - def last_update_length=(arg0); end - def refresh_with_format_change(*arg0); end - def resolve_format(*arg0); end -end -class ProgressBar::Time - def initialize(time = nil); end - def now; end - def time; end - def time=(arg0); end - def unmocked_time_method; end -end -class ProgressBar::Timer - def divide_seconds(seconds); end - def elapsed_seconds; end - def elapsed_whole_seconds; end - def initialize(options = nil); end - def pause; end - def reset; end - def reset?; end - def restart; end - def resume; end - def start; end - def started?; end - def started_at; end - def started_at=(arg0); end - def stop; end - def stopped?; end - def stopped_at; end - def stopped_at=(arg0); end - def time; end - def time=(arg0); end -end -class ProgressBar::InvalidProgressError < RuntimeError -end -class ProgressBar::Progress - def absolute; end - def decrement; end - def finish; end - def finished?; end - def increment; end - def initialize(options = nil); end - def none?; end - def percentage_completed; end - def percentage_completed_with_precision; end - def progress; end - def progress=(new_progress); end - def reset; end - def running_average; end - def running_average=(arg0); end - def smoothing; end - def smoothing=(arg0); end - def start(options = nil); end - def starting_position; end - def starting_position=(arg0); end - def total; end - def total=(new_total); end - def total_with_unknown_indicator; end - def unknown?; end -end -class ProgressBar::Throttle - def choke(options = nil); end - def initialize(options = nil); end - def rate; end - def rate=(arg0); end - def started_at; end - def started_at=(arg0); end - def stopped_at; end - def stopped_at=(arg0); end - def timer; end - def timer=(arg0); end -end -module ProgressBar::Calculators -end -class ProgressBar::Calculators::Length - def calculate_length; end - def current_length; end - def current_length=(arg0); end - def dynamic_width; end - def dynamic_width_stty; end - def dynamic_width_tput; end - def dynamic_width_via_io_object; end - def dynamic_width_via_output_stream_object; end - def dynamic_width_via_system_calls; end - def initialize(options = nil); end - def length; end - def length_changed?; end - def length_override; end - def length_override=(other); end - def output; end - def output=(arg0); end - def reset_length; end - def terminal_width; end - def unix?; end -end -class ProgressBar::Calculators::RunningAverage - def self.calculate(current_average, new_value_to_average, smoothing_factor); end -end -module ProgressBar::Components -end -class ProgressBar::Components::Bar - def bar(length); end - def bar_with_percentage(length); end - def complete_bar(length); end - def complete_bar_with_percentage(length); end - def completed_length; end - def incomplete_space(length); end - def incomplete_string; end - def initialize(options = nil); end - def integrated_percentage_complete_string; end - def length; end - def length=(arg0); end - def progress; end - def progress=(arg0); end - def progress_mark; end - def progress_mark=(arg0); end - def remainder_mark; end - def remainder_mark=(arg0); end - def standard_complete_string; end - def to_s(options = nil); end - def unknown_progress_frame; end - def unknown_string; end - def upa_steps; end - def upa_steps=(arg0); end -end -class ProgressBar::Components::Percentage - def initialize(options = nil); end - def justified_percentage; end - def justified_percentage_with_precision; end - def percentage; end - def percentage_with_precision; end - def progress; end - def progress=(arg0); end -end -class ProgressBar::Components::Rate - def base_rate; end - def elapsed_seconds; end - def initialize(options = nil); end - def progress; end - def progress=(arg0); end - def rate_of_change(format_string = nil); end - def rate_of_change_with_precision; end - def rate_scale; end - def rate_scale=(arg0); end - def scaled_rate; end - def started_at; end - def started_at=(arg0); end - def stopped_at; end - def stopped_at=(arg0); end - def timer; end - def timer=(arg0); end -end -class ProgressBar::Components::Time - def elapsed; end - def elapsed_with_label; end - def estimated; end - def estimated_seconds_remaining; end - def estimated_with_elapsed_fallback; end - def estimated_with_friendly_oob; end - def estimated_with_label; end - def estimated_with_no_oob; end - def estimated_with_unknown_oob; end - def initialize(options = nil); end - def out_of_bounds_time_format; end - def out_of_bounds_time_format=(format); end - def progress; end - def progress=(arg0); end - def timer; end - def timer=(arg0); end -end -class ProgressBar::Components::Title - def initialize(options = nil); end - def title; end - def title=(arg0); end -end -module ProgressBar::Format -end -class ProgressBar::Format::Molecule - def bar_molecule?; end - def full_key; end - def initialize(letter); end - def key; end - def key=(arg0); end - def lookup_value(environment, length = nil); end - def method_name; end - def method_name=(arg0); end - def non_bar_molecule?; end -end -class ProgressBar::Format::Formatter - def self.process(format_string, max_length, bar); end -end -class ProgressBar::Format::String < String - def bar_molecule_placeholder_length; end - def bar_molecules; end - def displayable_length; end - def molecules; end - def non_bar_molecules; end -end -class ProgressBar::Base - def autofinish; end - def autofinish=(arg0); end - def autostart; end - def autostart=(arg0); end - def bar; end - def bar=(arg0); end - def clear(*args, &block); end - def decrement; end - def finish; end - def finished; end - def finished=(arg0); end - def finished?; end - def format(other); end - def format=(other); end - def increment; end - def initialize(options = nil); end - def inspect; end - def log(*args, &block); end - def output; end - def output=(arg0); end - def pause; end - def paused?; end - def percentage; end - def percentage=(arg0); end - def progress(*args, &block); end - def progress=(new_progress); end - def progress_mark=(mark); end - def progressable; end - def progressable=(arg0); end - def rate; end - def rate=(arg0); end - def refresh(*args, &block); end - def remainder_mark=(mark); end - def reset; end - def resume; end - def start(options = nil); end - def started?; end - def stop; end - def stopped?; end - def time; end - def time=(arg0); end - def timer; end - def timer=(arg0); end - def title; end - def title=(title); end - def title_comp; end - def title_comp=(arg0); end - def to_h; end - def to_s(new_format = nil); end - def total(*args, &block); end - def total=(new_total); end - def update_progress(*args); end - extend Forwardable -end -module ProgressBar::Refinements -end -module ProgressBar::Refinements::Enumerator -end diff --git a/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi b/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi new file mode 100644 index 00000000..d8e2237b --- /dev/null +++ b/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi @@ -0,0 +1,1239 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `ruby-progressbar` gem. +# Please instead update this file by running `bin/tapioca gem ruby-progressbar`. + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:1 +class ProgressBar + class << self + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar.rb:19 + def create(*args); end + end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:4 +class ProgressBar::Base + extend ::Forwardable + + # @return [Base] a new instance of Base + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:16 + def initialize(options = T.unsafe(nil)); end + + # source://RUBY_ROOT/forwardable.rb:226 + def clear(*args, &block); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:88 + def decrement; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:44 + def finish; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:80 + def finished?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:154 + def format(other); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:154 + def format=(other); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:92 + def increment; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:150 + def inspect; end + + # source://RUBY_ROOT/forwardable.rb:226 + def log(*args, &block); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:54 + def pause; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:74 + def paused?; end + + # source://RUBY_ROOT/forwardable.rb:226 + def progress(*args, &block); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:96 + def progress=(new_progress); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:104 + def progress_mark=(mark); end + + # source://RUBY_ROOT/forwardable.rb:226 + def refresh(*args, &block); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:108 + def remainder_mark=(mark); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:66 + def reset; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:62 + def resume; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:39 + def start(options = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:84 + def started?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:58 + def stop; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:74 + def stopped?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:112 + def title; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:116 + def title=(title); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:127 + def to_h; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:120 + def to_s(new_format = T.unsafe(nil)); end + + # source://RUBY_ROOT/forwardable.rb:226 + def total(*args, &block); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:100 + def total=(new_total); end + + protected + + # Returns the value of attribute autofinish. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def autofinish; end + + # Sets the attribute autofinish + # + # @param value the value to set the attribute autofinish to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def autofinish=(_arg0); end + + # Returns the value of attribute autostart. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def autostart; end + + # Sets the attribute autostart + # + # @param value the value to set the attribute autostart to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def autostart=(_arg0); end + + # Returns the value of attribute bar. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def bar; end + + # Sets the attribute bar + # + # @param value the value to set the attribute bar to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def bar=(_arg0); end + + # Returns the value of attribute finished. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def finished; end + + # Sets the attribute finished + # + # @param value the value to set the attribute finished to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def finished=(_arg0); end + + # Returns the value of attribute output. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def output; end + + # Sets the attribute output + # + # @param value the value to set the attribute output to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def output=(_arg0); end + + # Returns the value of attribute percentage. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def percentage; end + + # Sets the attribute percentage + # + # @param value the value to set the attribute percentage to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def percentage=(_arg0); end + + # Returns the value of attribute progressable. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def progressable; end + + # Sets the attribute progressable + # + # @param value the value to set the attribute progressable to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def progressable=(_arg0); end + + # Returns the value of attribute rate. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def rate; end + + # Sets the attribute rate + # + # @param value the value to set the attribute rate to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def rate=(_arg0); end + + # Returns the value of attribute time. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def time; end + + # Sets the attribute time + # + # @param value the value to set the attribute time to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def time=(_arg0); end + + # Returns the value of attribute timer. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def timer; end + + # Sets the attribute timer + # + # @param value the value to set the attribute timer to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def timer=(_arg0); end + + # Returns the value of attribute title_comp. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def title_comp; end + + # Sets the attribute title_comp + # + # @param value the value to set the attribute title_comp to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:164 + def title_comp=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/base.rb:176 + def update_progress(*args); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:2 +module ProgressBar::Calculators; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:3 +class ProgressBar::Calculators::Length + # @return [Length] a new instance of Length + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:8 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:25 + def calculate_length; end + + # Returns the value of attribute current_length. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:5 + def current_length; end + + # Sets the attribute current_length + # + # @param value the value to set the attribute current_length to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:5 + def current_length=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:14 + def length; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:18 + def length_changed?; end + + # Returns the value of attribute length_override. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:4 + def length_override; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:33 + def length_override=(other); end + + # Returns the value of attribute output. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:5 + def output; end + + # Sets the attribute output + # + # @param value the value to set the attribute output to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:5 + def output=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:29 + def reset_length; end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:57 + def dynamic_width; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:87 + def dynamic_width_stty; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:91 + def dynamic_width_tput; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:78 + def dynamic_width_via_io_object; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:73 + def dynamic_width_via_output_stream_object; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:83 + def dynamic_width_via_system_calls; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:43 + def terminal_width; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/length.rb:95 + def unix?; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/running_average.rb:3 +class ProgressBar::Calculators::RunningAverage + class << self + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/calculators/running_average.rb:4 + def calculate(current_average, new_value_to_average, smoothing_factor); end + end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:5 +module ProgressBar::Components; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:6 +class ProgressBar::Components::Bar + # @return [Bar] a new instance of Bar + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:17 + def initialize(options = T.unsafe(nil)); end + + # Returns the value of attribute length. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def length; end + + # Sets the attribute length + # + # @param value the value to set the attribute length to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def length=(_arg0); end + + # Returns the value of attribute progress. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def progress; end + + # Sets the attribute progress + # + # @param value the value to set the attribute progress to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def progress=(_arg0); end + + # Returns the value of attribute progress_mark. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def progress_mark; end + + # Sets the attribute progress_mark + # + # @param value the value to set the attribute progress_mark to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def progress_mark=(_arg0); end + + # Returns the value of attribute remainder_mark. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def remainder_mark; end + + # Sets the attribute remainder_mark + # + # @param value the value to set the attribute remainder_mark to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def remainder_mark=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:25 + def to_s(options = T.unsafe(nil)); end + + # Returns the value of attribute upa_steps. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def upa_steps; end + + # Sets the attribute upa_steps + # + # @param value the value to set the attribute upa_steps to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:11 + def upa_steps=(_arg0); end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:51 + def bar(length); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:85 + def bar_with_percentage(length); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:57 + def complete_bar(length); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:63 + def complete_bar_with_percentage(length); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:91 + def completed_length; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:75 + def incomplete_space(length); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:47 + def incomplete_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:37 + def integrated_percentage_complete_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:43 + def standard_complete_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:95 + def unknown_progress_frame; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:69 + def unknown_string; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:7 +ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:8 +ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/bar.rb:9 +ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:3 +class ProgressBar::Components::Percentage + # @return [Percentage] a new instance of Percentage + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:6 + def initialize(options = T.unsafe(nil)); end + + # Returns the value of attribute progress. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:4 + def progress; end + + # Sets the attribute progress + # + # @param value the value to set the attribute progress to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:4 + def progress=(_arg0); end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:16 + def justified_percentage; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:24 + def justified_percentage_with_precision; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:12 + def percentage; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/percentage.rb:20 + def percentage_with_precision; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:3 +class ProgressBar::Components::Rate + # @return [Rate] a new instance of Rate + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:10 + def initialize(options = T.unsafe(nil)); end + + # Returns the value of attribute progress. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def progress; end + + # Sets the attribute progress + # + # @param value the value to set the attribute progress to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def progress=(_arg0); end + + # Returns the value of attribute rate_scale. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def rate_scale; end + + # Sets the attribute rate_scale + # + # @param value the value to set the attribute rate_scale to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def rate_scale=(_arg0); end + + # Returns the value of attribute started_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def started_at; end + + # Sets the attribute started_at + # + # @param value the value to set the attribute started_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def started_at=(_arg0); end + + # Returns the value of attribute stopped_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def stopped_at; end + + # Sets the attribute stopped_at + # + # @param value the value to set the attribute stopped_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def stopped_at=(_arg0); end + + # Returns the value of attribute timer. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def timer; end + + # Sets the attribute timer + # + # @param value the value to set the attribute timer to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:4 + def timer=(_arg0); end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:34 + def base_rate; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:38 + def elapsed_seconds; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:20 + def rate_of_change(format_string = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:26 + def rate_of_change_with_precision; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/rate.rb:30 + def scaled_rate; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:6 +class ProgressBar::Components::Time + # @return [Time] a new instance of Time + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:20 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:30 + def elapsed_with_label; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:26 + def estimated_with_label; end + + protected + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:48 + def estimated_with_friendly_oob; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:36 + def estimated_with_no_oob; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:42 + def estimated_with_unknown_oob; end + + # Returns the value of attribute out_of_bounds_time_format. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:54 + def out_of_bounds_time_format; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:58 + def out_of_bounds_time_format=(format); end + + # Returns the value of attribute progress. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:55 + def progress; end + + # Sets the attribute progress + # + # @param value the value to set the attribute progress to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:55 + def progress=(_arg0); end + + # Returns the value of attribute timer. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:55 + def timer; end + + # Sets the attribute timer + # + # @param value the value to set the attribute timer to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:55 + def timer=(_arg0); end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:82 + def elapsed; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:68 + def estimated; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:94 + def estimated_seconds_remaining; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:90 + def estimated_with_elapsed_fallback; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:14 +ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:13 +ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:12 +ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:11 +ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:9 +ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:15 +ProgressBar::Components::Time::OOB_TEXT_TO_FORMAT = T.let(T.unsafe(nil), Hash) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:8 +ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:10 +ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/time.rb:7 +ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb:3 +class ProgressBar::Components::Title + # @return [Title] a new instance of Title + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb:8 + def initialize(options = T.unsafe(nil)); end + + # Returns the value of attribute title. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb:6 + def title; end + + # Sets the attribute title + # + # @param value the value to set the attribute title to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb:6 + def title=(_arg0); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/components/title.rb:4 +ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:2 +module ProgressBar::Format; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/formatter.rb:3 +class ProgressBar::Format::Formatter + class << self + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/formatter.rb:4 + def process(format_string, max_length, bar); end + end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:3 +class ProgressBar::Format::Molecule + # @return [Molecule] a new instance of Molecule + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:32 + def initialize(letter); end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:37 + def bar_molecule?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:45 + def full_key; end + + # Returns the value of attribute key. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:29 + def key; end + + # Sets the attribute key + # + # @param value the value to set the attribute key to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:29 + def key=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:49 + def lookup_value(environment, length = T.unsafe(nil)); end + + # Returns the value of attribute method_name. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:29 + def method_name; end + + # Sets the attribute method_name + # + # @param value the value to set the attribute method_name to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:29 + def method_name=(_arg0); end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:41 + def non_bar_molecule?; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:27 +ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/molecule.rb:4 +ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:3 +class ProgressBar::Format::String < ::String + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:11 + def bar_molecule_placeholder_length; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:19 + def bar_molecules; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:7 + def displayable_length; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:23 + def molecules; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:15 + def non_bar_molecules; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:5 +ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/format/string.rb:4 +ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/errors/invalid_progress_error.rb:2 +class ProgressBar::InvalidProgressError < ::RuntimeError; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:2 +class ProgressBar::Output + # @return [Output] a new instance of Output + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:7 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:34 + def clear_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:38 + def length; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:27 + def log(string); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:47 + def refresh(options = T.unsafe(nil)); end + + # Returns the value of attribute stream. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:5 + def stream; end + + # Sets the attribute stream + # + # @param value the value to set the attribute stream to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:5 + def stream=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:42 + def with_refresh; end + + protected + + # Returns the value of attribute bar. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def bar; end + + # Sets the attribute bar + # + # @param value the value to set the attribute bar to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def bar=(_arg0); end + + # Returns the value of attribute length_calculator. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def length_calculator; end + + # Sets the attribute length_calculator + # + # @param value the value to set the attribute length_calculator to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def length_calculator=(_arg0); end + + # Returns the value of attribute throttle. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def throttle; end + + # Sets the attribute throttle + # + # @param value the value to set the attribute throttle to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:57 + def throttle=(_arg0); end + + private + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:63 + def print_and_flush; end + + class << self + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:17 + def detect(options = T.unsafe(nil)); end + end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:3 +ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:4 +module ProgressBar::Outputs; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:5 +class ProgressBar::Outputs::NonTty < ::ProgressBar::Output + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:18 + def bar_update_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:8 + def clear; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:28 + def default_format; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:38 + def eol; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:14 + def last_update_length; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:36 + def refresh_with_format_change(*_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:32 + def resolve_format(*_arg0); end + + protected + + # Sets the attribute last_update_length + # + # @param value the value to set the attribute last_update_length to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:44 + def last_update_length=(_arg0); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/non_tty.rb:6 +ProgressBar::Outputs::NonTty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:5 +class ProgressBar::Outputs::Tty < ::ProgressBar::Output + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:15 + def bar_update_string; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:10 + def clear; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:19 + def default_format; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:27 + def eol; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/output.rb:42 + def refresh_with_format_change; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:23 + def resolve_format(other_format); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/outputs/tty.rb:6 +ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:4 +class ProgressBar::Progress + # @return [Progress] a new instance of Progress + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:16 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:114 + def absolute; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:47 + def decrement; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:29 + def finish; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:33 + def finished?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:37 + def increment; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:95 + def none?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:83 + def percentage_completed; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:107 + def percentage_completed_with_precision; end + + # Returns the value of attribute progress. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:9 + def progress; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:61 + def progress=(new_progress); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:57 + def reset; end + + # Returns the value of attribute running_average. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def running_average; end + + # Sets the attribute running_average + # + # @param value the value to set the attribute running_average to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def running_average=(_arg0); end + + # Returns the value of attribute smoothing. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def smoothing; end + + # Sets the attribute smoothing + # + # @param value the value to set the attribute smoothing to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def smoothing=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:23 + def start(options = T.unsafe(nil)); end + + # Returns the value of attribute starting_position. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def starting_position; end + + # Sets the attribute starting_position + # + # @param value the value to set the attribute starting_position to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:12 + def starting_position=(_arg0); end + + # Returns the value of attribute total. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:9 + def total; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:74 + def total=(new_total); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:103 + def total_with_unknown_indicator; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:99 + def unknown?; end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:6 +ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:7 +ProgressBar::Progress::DEFAULT_SMOOTHING = T.let(T.unsafe(nil), Float) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/progress.rb:5 +ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements/enumerator.rb:2 +module ProgressBar::Refinements; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/refinements/enumerator.rb:3 +module ProgressBar::Refinements::Enumerator; end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:2 +class ProgressBar::Throttle + # @return [Throttle] a new instance of Throttle + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:8 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:15 + def choke(options = T.unsafe(nil)); end + + # Returns the value of attribute rate. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def rate; end + + # Sets the attribute rate + # + # @param value the value to set the attribute rate to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def rate=(_arg0); end + + # Returns the value of attribute started_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def started_at; end + + # Sets the attribute started_at + # + # @param value the value to set the attribute started_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def started_at=(_arg0); end + + # Returns the value of attribute stopped_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def stopped_at; end + + # Sets the attribute stopped_at + # + # @param value the value to set the attribute stopped_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def stopped_at=(_arg0); end + + # Returns the value of attribute timer. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def timer; end + + # Sets the attribute timer + # + # @param value the value to set the attribute timer to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/throttle.rb:3 + def timer=(_arg0); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:3 +class ProgressBar::Time + # @return [Time] a new instance of Time + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:11 + def initialize(time = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:15 + def now; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:19 + def unmocked_time_method; end + + protected + + # Returns the value of attribute time. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:29 + def time; end + + # Sets the attribute time + # + # @param value the value to set the attribute time to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:29 + def time=(_arg0); end +end + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/time.rb:4 +ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array) + +# source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:4 +class ProgressBar::Timer + # @return [Timer] a new instance of Timer + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:8 + def initialize(options = T.unsafe(nil)); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:61 + def divide_seconds(seconds); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:53 + def elapsed_seconds; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:57 + def elapsed_whole_seconds; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:23 + def pause; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:39 + def reset; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:44 + def reset?; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:48 + def restart; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:27 + def resume; end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:12 + def start; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:31 + def started?; end + + # Returns the value of attribute started_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:5 + def started_at; end + + # Sets the attribute started_at + # + # @param value the value to set the attribute started_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:5 + def started_at=(_arg0); end + + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:17 + def stop; end + + # @return [Boolean] + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:35 + def stopped?; end + + # Returns the value of attribute stopped_at. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:5 + def stopped_at; end + + # Sets the attribute stopped_at + # + # @param value the value to set the attribute stopped_at to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:5 + def stopped_at=(_arg0); end + + protected + + # Returns the value of attribute time. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:70 + def time; end + + # Sets the attribute time + # + # @param value the value to set the attribute time to. + # + # source://ruby-progressbar-1.11.0/lib/ruby-progressbar/timer.rb:70 + def time=(_arg0); end +end diff --git a/sorbet/rbi/gems/simplecov-html.rbi b/sorbet/rbi/gems/simplecov-html.rbi deleted file mode 100644 index 88f51043..00000000 --- a/sorbet/rbi/gems/simplecov-html.rbi +++ /dev/null @@ -1,35 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov-html/all/simplecov-html.rbi -# -# simplecov-html-0.12.3 - -module SimpleCov -end -module SimpleCov::Formatter -end -class SimpleCov::Formatter::HTMLFormatter - def asset_output_path; end - def assets_path(name); end - def branchable_result?; end - def coverage_css_class(covered_percent); end - def covered_percent(percent); end - def format(result); end - def formatted_file_list(title, source_files); end - def formatted_source_file(source_file); end - def id(source_file); end - def initialize; end - def line_status?(source_file, line); end - def link_to_source_file(source_file); end - def output_message(result); end - def output_path; end - def shortened_filename(source_file); end - def strength_css_class(covered_strength); end - def template(name); end - def timeago(time); end -end diff --git a/sorbet/rbi/gems/simplecov-html@0.12.3.rbi b/sorbet/rbi/gems/simplecov-html@0.12.3.rbi new file mode 100644 index 00000000..b89ca632 --- /dev/null +++ b/sorbet/rbi/gems/simplecov-html@0.12.3.rbi @@ -0,0 +1,364 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `simplecov-html` gem. +# Please instead update this file by running `bin/tapioca gem simplecov-html`. + +# Code coverage for ruby. Please check out README for a full introduction. +# +# source://simplecov-html-0.12.3/lib/simplecov-html.rb:16 +module SimpleCov + class << self + # source://simplecov-0.21.2/lib/simplecov.rb:174 + def at_exit_behavior; end + + # Clear out the previously cached .result. Primarily useful in testing + # + # source://simplecov-0.21.2/lib/simplecov.rb:170 + def clear_result; end + + # Collate a series of SimpleCov result files into a single SimpleCov output. + # + # You can optionally specify configuration with a block: + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do + # add_filter 'test' + # end + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do + # add_filter 'test' + # end + # + # Please check out the RDoc for SimpleCov::Configuration to find about + # available config options, or checkout the README for more in-depth + # information about coverage collation + # + # By default `collate` ignores the merge_timeout so all results of all files specified will be + # merged together. If you want to honor the merge_timeout then provide the keyword argument + # `ignore_timeout: false`. + # + # source://simplecov-0.21.2/lib/simplecov.rb:86 + def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end + + # Thinking: Move this behavior earlier so if there was an error we do nothing? + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:223 + def exit_and_report_previous_error(exit_status); end + + # Returns the exit status from the exit exception + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:200 + def exit_status_from_exception; end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit; end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit=(_arg0); end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit?; end + + # Applies the configured filters to the given array of SimpleCov::SourceFile items + # + # source://simplecov-0.21.2/lib/simplecov.rb:131 + def filtered(files); end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:268 + def final_result_process?; end + + # Applies the configured groups to the given array of SimpleCov::SourceFile items + # + # source://simplecov-0.21.2/lib/simplecov.rb:142 + def grouped(files); end + + # source://simplecov-0.21.2/lib/simplecov.rb:162 + def load_adapter(name); end + + # Applies the profile of given name on SimpleCov configuration + # + # source://simplecov-0.21.2/lib/simplecov.rb:158 + def load_profile(name); end + + # Returns the value of attribute pid. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def pid; end + + # Sets the attribute pid + # + # @param value the value to set the attribute pid to. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def pid=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:213 + def previous_error?(error_exit_status); end + + # Usage: + # exit_status = SimpleCov.process_result(SimpleCov.result, exit_status) + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:248 + def process_result(result); end + + # source://simplecov-0.21.2/lib/simplecov.rb:233 + def process_results_and_report_error; end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:229 + def ready_to_process_results?; end + + # Returns the result for the current coverage run, merging it across test suites + # from cache using SimpleCov::ResultMerger if use_merging is activated (default) + # + # source://simplecov-0.21.2/lib/simplecov.rb:101 + def result; end + + # Returns nil if the result has not been computed + # Otherwise, returns the result + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:124 + def result?; end + + # source://simplecov-0.21.2/lib/simplecov.rb:256 + def result_exit_status(result); end + + # Rounding down to be extra strict, see #679 + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:296 + def round_coverage(coverage); end + + # Called from at_exit block + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:186 + def run_exit_tasks!; end + + # Returns the value of attribute running. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def running; end + + # Sets the attribute running + # + # @param value the value to set the attribute running to. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def running=(_arg0); end + + # Sets up SimpleCov to run against your project. + # You can optionally specify a profile to use as well as configuration with a block: + # SimpleCov.start + # OR + # SimpleCov.start 'rails' # using rails profile + # OR + # SimpleCov.start do + # add_filter 'test' + # end + # OR + # SimpleCov.start 'rails' do + # add_filter 'test' + # end + # + # Please check out the RDoc for SimpleCov::Configuration to find about available config options + # + # source://simplecov-0.21.2/lib/simplecov.rb:48 + def start(profile = T.unsafe(nil), &block); end + + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:276 + def wait_for_other_processes; end + + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:285 + def write_last_run(result); end + + private + + # Unite the result so it wouldn't matter what coverage type was called + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:397 + def adapt_coverage_result; end + + # Finds files that were to be tracked but were not loaded and initializes + # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc). + # + # source://simplecov-0.21.2/lib/simplecov.rb:369 + def add_not_loaded_files(result); end + + # source://simplecov-0.21.2/lib/simplecov.rb:302 + def initial_setup(profile, &block); end + + # source://simplecov-0.21.2/lib/simplecov.rb:361 + def lookup_corresponding_ruby_coverage_name(criterion); end + + # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772 + # + # source://simplecov-0.21.2/lib/simplecov.rb:423 + def make_parallel_tests_available; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:432 + def probably_running_parallel_tests?; end + + # Call steps that handle process coverage result + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:386 + def process_coverage_result; end + + # Filter coverage result + # The result before filter also has result of coverage for files + # are not related to the project like loaded gems coverage. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:408 + def remove_useless_results; end + + # Initialize result with files that are not included by coverage + # and added inside the config block + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:418 + def result_with_not_loaded_files; end + + # Trigger Coverage.start depends on given config coverage_criterion + # + # With Positive branch it supports all coverage measurement types + # With Negative branch it supports only line coverage measurement type + # + # source://simplecov-0.21.2/lib/simplecov.rb:314 + def start_coverage_measurement; end + + # source://simplecov-0.21.2/lib/simplecov.rb:349 + def start_coverage_with_criteria; end + end +end + +# TODO: Documentation on how to build your own formatters +# +# source://simplecov-html-0.12.3/lib/simplecov-html.rb:17 +module SimpleCov::Formatter + class << self + # source://simplecov-0.21.2/lib/simplecov/default_formatter.rb:7 + def from_env(env); end + end +end + +# source://simplecov-html-0.12.3/lib/simplecov-html.rb:18 +class SimpleCov::Formatter::HTMLFormatter + # @return [HTMLFormatter] a new instance of HTMLFormatter + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:19 + def initialize; end + + # @return [Boolean] + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:38 + def branchable_result?; end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:23 + def format(result); end + + # @return [Boolean] + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:45 + def line_status?(source_file, line); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:34 + def output_message(result); end + + private + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:64 + def asset_output_path; end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:72 + def assets_path(name); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:97 + def coverage_css_class(covered_percent); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:93 + def covered_percent(percent); end + + # Returns a table containing the given source files + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:84 + def formatted_file_list(title, source_files); end + + # Returns the html for the given source_file + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:77 + def formatted_source_file(source_file); end + + # Return a (kind of) unique id for the source file given. Uses SHA1 on path for the id + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:118 + def id(source_file); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:130 + def link_to_source_file(source_file); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:60 + def output_path; end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:126 + def shortened_filename(source_file); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:107 + def strength_css_class(covered_strength); end + + # Returns the an erb instance for the template of given name + # + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:56 + def template(name); end + + # source://simplecov-html-0.12.3/lib/simplecov-html.rb:122 + def timeago(time); end +end + +# source://simplecov-html-0.12.3/lib/simplecov-html/version.rb:6 +SimpleCov::Formatter::HTMLFormatter::VERSION = T.let(T.unsafe(nil), String) + +# source://simplecov-0.21.2/lib/simplecov/version.rb:4 +SimpleCov::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/simplecov.rbi b/sorbet/rbi/gems/simplecov.rbi deleted file mode 100644 index f6f9dd19..00000000 --- a/sorbet/rbi/gems/simplecov.rbi +++ /dev/null @@ -1,419 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov/all/simplecov.rbi -# -# simplecov-0.21.2 - -module SimpleCov - def self.adapt_coverage_result; end - def self.add_not_loaded_files(result); end - def self.at_exit_behavior; end - def self.clear_result; end - def self.collate(result_filenames, profile = nil, ignore_timeout: nil, &block); end - def self.exit_and_report_previous_error(exit_status); end - def self.exit_status_from_exception; end - def self.external_at_exit; end - def self.external_at_exit=(arg0); end - def self.external_at_exit?; end - def self.filtered(files); end - def self.final_result_process?; end - def self.grouped(files); end - def self.initial_setup(profile, &block); end - def self.load_adapter(name); end - def self.load_profile(name); end - def self.lookup_corresponding_ruby_coverage_name(criterion); end - def self.make_parallel_tests_available; end - def self.pid; end - def self.pid=(arg0); end - def self.previous_error?(error_exit_status); end - def self.probably_running_parallel_tests?; end - def self.process_coverage_result; end - def self.process_result(result); end - def self.process_results_and_report_error; end - def self.ready_to_process_results?; end - def self.remove_useless_results; end - def self.result; end - def self.result?; end - def self.result_exit_status(result); end - def self.result_with_not_loaded_files; end - def self.round_coverage(coverage); end - def self.run_exit_tasks!; end - def self.running; end - def self.running=(arg0); end - def self.start(profile = nil, &block); end - def self.start_coverage_measurement; end - def self.start_coverage_with_criteria; end - def self.wait_for_other_processes; end - def self.write_last_run(result); end - extend SimpleCov::Configuration -end -module SimpleCov::Formatter - def self.from_env(env); end -end -class SimpleCov::Formatter::MultiFormatter - def self.[](*args); end - def self.new(formatters = nil); end -end -module SimpleCov::Formatter::MultiFormatter::InstanceMethods - def format(result); end -end -module SimpleCov::Configuration - def adapters; end - def add_filter(filter_argument = nil, &filter_proc); end - def add_group(group_name, filter_argument = nil, &filter_proc); end - def at_exit(&block); end - def at_fork(&block); end - def branch_coverage?; end - def branch_coverage_supported?; end - def clear_coverage_criteria; end - def command_name(name = nil); end - def configure(&block); end - def coverage_criteria; end - def coverage_criterion(criterion = nil); end - def coverage_criterion_enabled?(criterion); end - def coverage_dir(dir = nil); end - def coverage_path; end - def coverage_start_arguments_supported?; end - def enable_coverage(criterion); end - def enable_for_subprocesses(value = nil); end - def enabled_for_subprocesses?; end - def filters; end - def filters=(arg0); end - def formatter(formatter = nil); end - def formatter=(arg0); end - def formatters; end - def formatters=(formatters); end - def groups; end - def groups=(arg0); end - def maximum_coverage_drop(coverage_drop = nil); end - def merge_timeout(seconds = nil); end - def minimum_coverage(coverage = nil); end - def minimum_coverage_by_file(coverage = nil); end - def minimum_possible_coverage_exceeded(coverage_option); end - def nocov_token(nocov_token = nil); end - def parse_filter(filter_argument = nil, &filter_proc); end - def primary_coverage(criterion = nil); end - def print_error_status; end - def print_error_status=(arg0); end - def profiles; end - def project_name(new_name = nil); end - def raise_if_criterion_disabled(criterion); end - def raise_if_criterion_unsupported(criterion); end - def raise_on_invalid_coverage(coverage, coverage_setting); end - def refuse_coverage_drop(*criteria); end - def root(root = nil); end - def skip_token(nocov_token = nil); end - def track_files(glob); end - def tracked_files; end - def use_merging(use = nil); end -end -class SimpleCov::CoverageStatistics - def compute_percent(covered, missed, total); end - def compute_strength(total_strength, total); end - def covered; end - def initialize(covered:, missed:, total_strength: nil); end - def missed; end - def percent; end - def self.from(coverage_statistics); end - def strength; end - def total; end -end -module SimpleCov::ExitCodes -end -module SimpleCov::ExitCodes::ExitCodeHandling - def call(result, coverage_limits:); end - def coverage_checks(result, coverage_limits); end - def self.call(result, coverage_limits:); end - def self.coverage_checks(result, coverage_limits); end -end -class SimpleCov::ExitCodes::MaximumCoverageDropCheck - def compute_coverage_drop_data; end - def coverage_drop_violations; end - def drop_percent(criterion); end - def exit_code; end - def failing?; end - def initialize(result, maximum_coverage_drop); end - def last_coverage(criterion); end - def last_run; end - def maximum_coverage_drop; end - def report; end - def result; end -end -class SimpleCov::ExitCodes::MinimumCoverageByFileCheck - def compute_minimum_coverage_data; end - def exit_code; end - def failing?; end - def initialize(result, minimum_coverage_by_file); end - def minimum_coverage_by_file; end - def minimum_violations; end - def report; end - def result; end -end -class SimpleCov::ExitCodes::MinimumOverallCoverageCheck - def calculate_minimum_violations; end - def exit_code; end - def failing?; end - def initialize(result, minimum_coverage); end - def minimum_coverage; end - def minimum_violations; end - def report; end - def result; end -end -class SimpleCov::Profiles < Hash - def define(name, &blk); end - def load(name); end -end -class SimpleCov::SourceFile - def branch_coverage_statistics; end - def branches; end - def branches_coverage_percent; end - def branches_for_line(line_number); end - def branches_report; end - def build_branch(branch_data, hit_count, condition_start_line); end - def build_branches; end - def build_branches_from(condition, branches); end - def build_branches_report; end - def build_lines; end - def build_no_cov_chunks; end - def coverage_data; end - def coverage_exceeding_source_warn; end - def coverage_statistics; end - def covered_branches; end - def covered_lines; end - def covered_percent; end - def covered_strength; end - def ensure_remove_undefs(file_lines); end - def filename; end - def initialize(filename, coverage_data); end - def line(number); end - def line_coverage_statistics; end - def line_with_missed_branch?(line_number); end - def lines; end - def lines_of_code; end - def lines_strength; end - def load_source; end - def missed_branches; end - def missed_lines; end - def never_lines; end - def no_branches?; end - def no_cov_chunks; end - def no_lines?; end - def process_skipped_branches(branches); end - def process_skipped_lines(lines); end - def project_filename; end - def read_lines(file, lines, current_line); end - def relevant_lines; end - def restore_ruby_data_structure(structure); end - def set_encoding_based_on_magic_comment(file, line); end - def shebang?(line); end - def skipped_lines; end - def source; end - def source_lines; end - def src; end - def total_branches; end -end -class SimpleCov::SourceFile::Line - def coverage; end - def covered?; end - def initialize(src, line_number, coverage); end - def line; end - def line_number; end - def missed?; end - def never?; end - def number; end - def skipped!; end - def skipped; end - def skipped?; end - def source; end - def src; end - def status; end -end -class SimpleCov::SourceFile::Branch - def coverage; end - def covered?; end - def end_line; end - def initialize(start_line:, end_line:, coverage:, inline:, type:); end - def inline?; end - def missed?; end - def overlaps_with?(line_range); end - def report; end - def report_line; end - def skipped!; end - def skipped?; end - def start_line; end - def type; end -end -class SimpleCov::FileList - def branch_covered_percent; end - def compute_coverage_statistics; end - def compute_coverage_statistics_by_file; end - def count(*args, &block); end - def coverage_statistics; end - def coverage_statistics_by_file; end - def covered_branches; end - def covered_lines; end - def covered_percent; end - def covered_percentages; end - def covered_strength; end - def each(*args, &block); end - def empty?(*args, &block); end - def initialize(files); end - def least_covered_file; end - def length(*args, &block); end - def lines_of_code; end - def map(*args, &block); end - def missed_branches; end - def missed_lines; end - def never_lines; end - def size(*args, &block); end - def skipped_lines; end - def to_a(*args, &block); end - def to_ary(*args, &block); end - def total_branches; end - extend Forwardable - include Enumerable -end -class SimpleCov::Result - def command_name; end - def command_name=(arg0); end - def coverage; end - def coverage_statistics(*args, &block); end - def coverage_statistics_by_file(*args, &block); end - def covered_branches(*args, &block); end - def covered_lines(*args, &block); end - def covered_percent(*args, &block); end - def covered_percentages(*args, &block); end - def covered_strength(*args, &block); end - def created_at; end - def created_at=(arg0); end - def filenames; end - def files; end - def filter!; end - def format!; end - def groups; end - def initialize(original_result, command_name: nil, created_at: nil); end - def least_covered_file(*args, &block); end - def missed_branches(*args, &block); end - def missed_lines(*args, &block); end - def original_result; end - def self.from_hash(hash); end - def source_files; end - def to_hash; end - def total_branches(*args, &block); end - def total_lines(*args, &block); end - extend Forwardable -end -class SimpleCov::Filter - def filter_argument; end - def initialize(filter_argument); end - def matches?(_source_file); end - def passes?(source_file); end - def self.build_filter(filter_argument); end - def self.class_for_argument(filter_argument); end -end -class SimpleCov::StringFilter < SimpleCov::Filter - def matches?(source_file); end -end -class SimpleCov::RegexFilter < SimpleCov::Filter - def matches?(source_file); end -end -class SimpleCov::BlockFilter < SimpleCov::Filter - def matches?(source_file); end -end -class SimpleCov::ArrayFilter < SimpleCov::Filter - def initialize(filter_argument); end - def matches?(source_files_list); end -end -class SimpleCov::Formatter::SimpleFormatter - def format(result); end -end -module SimpleCov::LastRun - def self.last_run_path; end - def self.read; end - def self.write(json); end -end -class SimpleCov::LinesClassifier - def classify(lines); end - def self.no_cov_line; end - def self.no_cov_line?(line); end - def self.whitespace_line?(line); end -end -module SimpleCov::ResultMerger - def self.adapt_pre_simplecov_0_18_result(result); end - def self.adapt_result(result); end - def self.create_result(command_names, coverage); end - def self.merge_and_store(*file_paths, ignore_timeout: nil); end - def self.merge_coverage(*results); end - def self.merge_results(*file_paths, ignore_timeout: nil); end - def self.merge_valid_results(results, ignore_timeout: nil); end - def self.merged_result; end - def self.parse_file(path); end - def self.parse_json(content); end - def self.pre_simplecov_0_18_result?(result); end - def self.read_file(path); end - def self.read_resultset; end - def self.resultset_path; end - def self.resultset_writelock; end - def self.store_result(result); end - def self.synchronize_resultset; end - def self.time_since_result_creation(data); end - def self.valid_results(file_path, ignore_timeout: nil); end - def self.within_merge_timeout?(data); end -end -module SimpleCov::CommandGuesser - def self.from_command_line_options; end - def self.from_defined_constants; end - def self.from_env; end - def self.guess; end - def self.original_run_command; end - def self.original_run_command=(arg0); end -end -class SimpleCov::ResultAdapter - def adapt; end - def initialize(result); end - def result; end - def self.call(*args); end -end -module SimpleCov::Combine - def combine(combiner_module, coverage_a, coverage_b); end - def empty_coverage?(coverage_a, coverage_b); end - def existing_coverage(coverage_a, coverage_b); end - def self.combine(combiner_module, coverage_a, coverage_b); end - def self.empty_coverage?(coverage_a, coverage_b); end - def self.existing_coverage(coverage_a, coverage_b); end -end -module SimpleCov::Combine::BranchesCombiner - def combine(coverage_a, coverage_b); end - def self.combine(coverage_a, coverage_b); end -end -module SimpleCov::Combine::FilesCombiner - def combine(coverage_a, coverage_b); end - def self.combine(coverage_a, coverage_b); end -end -module SimpleCov::Combine::LinesCombiner - def combine(coverage_a, coverage_b); end - def merge_line_coverage(first_val, second_val); end - def self.combine(coverage_a, coverage_b); end - def self.merge_line_coverage(first_val, second_val); end -end -module SimpleCov::Combine::ResultsCombiner - def combine(*results); end - def combine_file_coverage(coverage_a, coverage_b); end - def combine_result_sets(combined_results, result); end - def self.combine(*results); end - def self.combine_file_coverage(coverage_a, coverage_b); end - def self.combine_result_sets(combined_results, result); end -end -module SimpleCov::UselessResultsRemover - def self.call(coverage_result); end - def self.root_regx; end -end -module SimpleCov::SimulateCoverage - def call(absolute_path); end - def self.call(absolute_path); end -end diff --git a/sorbet/rbi/gems/simplecov@0.21.2.rbi b/sorbet/rbi/gems/simplecov@0.21.2.rbi new file mode 100644 index 00000000..b514eb79 --- /dev/null +++ b/sorbet/rbi/gems/simplecov@0.21.2.rbi @@ -0,0 +1,2132 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `simplecov` gem. +# Please instead update this file by running `bin/tapioca gem simplecov`. + +# Code coverage for ruby. Please check out README for a full introduction. +# +# source://simplecov-0.21.2/lib/simplecov.rb:22 +module SimpleCov + extend ::SimpleCov::Configuration + + class << self + # source://simplecov-0.21.2/lib/simplecov.rb:174 + def at_exit_behavior; end + + # Clear out the previously cached .result. Primarily useful in testing + # + # source://simplecov-0.21.2/lib/simplecov.rb:170 + def clear_result; end + + # Collate a series of SimpleCov result files into a single SimpleCov output. + # + # You can optionally specify configuration with a block: + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' # using rails profile + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"] do + # add_filter 'test' + # end + # OR + # SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], 'rails' do + # add_filter 'test' + # end + # + # Please check out the RDoc for SimpleCov::Configuration to find about + # available config options, or checkout the README for more in-depth + # information about coverage collation + # + # By default `collate` ignores the merge_timeout so all results of all files specified will be + # merged together. If you want to honor the merge_timeout then provide the keyword argument + # `ignore_timeout: false`. + # + # source://simplecov-0.21.2/lib/simplecov.rb:86 + def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end + + # Thinking: Move this behavior earlier so if there was an error we do nothing? + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:223 + def exit_and_report_previous_error(exit_status); end + + # Returns the exit status from the exit exception + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:200 + def exit_status_from_exception; end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit; end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit=(_arg0); end + + # Basically, should we take care of at_exit behavior or something else? + # Used by the minitest plugin. See lib/minitest/simplecov_plugin.rb + # + # source://simplecov-0.21.2/lib/simplecov.rb:28 + def external_at_exit?; end + + # Applies the configured filters to the given array of SimpleCov::SourceFile items + # + # source://simplecov-0.21.2/lib/simplecov.rb:131 + def filtered(files); end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:268 + def final_result_process?; end + + # Applies the configured groups to the given array of SimpleCov::SourceFile items + # + # source://simplecov-0.21.2/lib/simplecov.rb:142 + def grouped(files); end + + # source://simplecov-0.21.2/lib/simplecov.rb:162 + def load_adapter(name); end + + # Applies the profile of given name on SimpleCov configuration + # + # source://simplecov-0.21.2/lib/simplecov.rb:158 + def load_profile(name); end + + # Returns the value of attribute pid. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def pid; end + + # Sets the attribute pid + # + # @param value the value to set the attribute pid to. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def pid=(_arg0); end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:213 + def previous_error?(error_exit_status); end + + # Usage: + # exit_status = SimpleCov.process_result(SimpleCov.result, exit_status) + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:248 + def process_result(result); end + + # source://simplecov-0.21.2/lib/simplecov.rb:233 + def process_results_and_report_error; end + + # @api private + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:229 + def ready_to_process_results?; end + + # Returns the result for the current coverage run, merging it across test suites + # from cache using SimpleCov::ResultMerger if use_merging is activated (default) + # + # source://simplecov-0.21.2/lib/simplecov.rb:101 + def result; end + + # Returns nil if the result has not been computed + # Otherwise, returns the result + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:124 + def result?; end + + # source://simplecov-0.21.2/lib/simplecov.rb:256 + def result_exit_status(result); end + + # Rounding down to be extra strict, see #679 + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:296 + def round_coverage(coverage); end + + # Called from at_exit block + # + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:186 + def run_exit_tasks!; end + + # Returns the value of attribute running. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def running; end + + # Sets the attribute running + # + # @param value the value to set the attribute running to. + # + # source://simplecov-0.21.2/lib/simplecov.rb:24 + def running=(_arg0); end + + # Sets up SimpleCov to run against your project. + # You can optionally specify a profile to use as well as configuration with a block: + # SimpleCov.start + # OR + # SimpleCov.start 'rails' # using rails profile + # OR + # SimpleCov.start do + # add_filter 'test' + # end + # OR + # SimpleCov.start 'rails' do + # add_filter 'test' + # end + # + # Please check out the RDoc for SimpleCov::Configuration to find about available config options + # + # source://simplecov-0.21.2/lib/simplecov.rb:48 + def start(profile = T.unsafe(nil), &block); end + + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:276 + def wait_for_other_processes; end + + # @api private + # + # source://simplecov-0.21.2/lib/simplecov.rb:285 + def write_last_run(result); end + + private + + # Unite the result so it wouldn't matter what coverage type was called + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:397 + def adapt_coverage_result; end + + # Finds files that were to be tracked but were not loaded and initializes + # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc). + # + # source://simplecov-0.21.2/lib/simplecov.rb:369 + def add_not_loaded_files(result); end + + # source://simplecov-0.21.2/lib/simplecov.rb:302 + def initial_setup(profile, &block); end + + # source://simplecov-0.21.2/lib/simplecov.rb:361 + def lookup_corresponding_ruby_coverage_name(criterion); end + + # parallel_tests isn't always available, see: https://github.com/grosser/parallel_tests/issues/772 + # + # source://simplecov-0.21.2/lib/simplecov.rb:423 + def make_parallel_tests_available; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov.rb:432 + def probably_running_parallel_tests?; end + + # Call steps that handle process coverage result + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:386 + def process_coverage_result; end + + # Filter coverage result + # The result before filter also has result of coverage for files + # are not related to the project like loaded gems coverage. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:408 + def remove_useless_results; end + + # Initialize result with files that are not included by coverage + # and added inside the config block + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov.rb:418 + def result_with_not_loaded_files; end + + # Trigger Coverage.start depends on given config coverage_criterion + # + # With Positive branch it supports all coverage measurement types + # With Negative branch it supports only line coverage measurement type + # + # source://simplecov-0.21.2/lib/simplecov.rb:314 + def start_coverage_measurement; end + + # source://simplecov-0.21.2/lib/simplecov.rb:349 + def start_coverage_with_criteria; end + end +end + +# source://simplecov-0.21.2/lib/simplecov/filter.rb:77 +class SimpleCov::ArrayFilter < ::SimpleCov::Filter + # @return [ArrayFilter] a new instance of ArrayFilter + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:78 + def initialize(filter_argument); end + + # Returns true if any of the filters in the array match the given source file. + # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }]) + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:88 + def matches?(source_files_list); end +end + +# source://simplecov-0.21.2/lib/simplecov/filter.rb:71 +class SimpleCov::BlockFilter < ::SimpleCov::Filter + # Returns true if the block given when initializing this filter with BlockFilter.new {|src_file| ... } + # returns true for the given source file. + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:72 + def matches?(source_file); end +end + +# Functionally for combining coverage results +# +# source://simplecov-0.21.2/lib/simplecov/combine.rb:6 +module SimpleCov::Combine + private + + # Combine two coverage based on the given combiner_module. + # + # Combiners should always be called through this interface, + # as it takes care of short-circuiting of one of the coverages is nil. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine.rb:16 + def combine(combiner_module, coverage_a, coverage_b); end + + # source://simplecov-0.21.2/lib/simplecov/combine.rb:22 + def empty_coverage?(coverage_a, coverage_b); end + + # source://simplecov-0.21.2/lib/simplecov/combine.rb:26 + def existing_coverage(coverage_a, coverage_b); end + + class << self + # Combine two coverage based on the given combiner_module. + # + # Combiners should always be called through this interface, + # as it takes care of short-circuiting of one of the coverages is nil. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine.rb:16 + def combine(combiner_module, coverage_a, coverage_b); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/combine.rb:22 + def empty_coverage?(coverage_a, coverage_b); end + + # source://simplecov-0.21.2/lib/simplecov/combine.rb:26 + def existing_coverage(coverage_a, coverage_b); end + end +end + +# Combine different branch coverage results on single file. +# +# Should be called through `SimpleCov.combine`. +# +# source://simplecov-0.21.2/lib/simplecov/combine/branches_combiner.rb:9 +module SimpleCov::Combine::BranchesCombiner + private + + # Return merged branches or the existed brach if other is missing. + # + # Branches inside files are always same if they exist, the difference only in coverage count. + # Branch coverage report for any conditional case is built from hash, it's key is a condition and + # it's body is a hash << keys from condition and value is coverage rate >>. + # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...} + # We create copy of result and update it values depending on the combined branches coverage values. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/branches_combiner.rb:23 + def combine(coverage_a, coverage_b); end + + class << self + # Return merged branches or the existed brach if other is missing. + # + # Branches inside files are always same if they exist, the difference only in coverage count. + # Branch coverage report for any conditional case is built from hash, it's key is a condition and + # it's body is a hash << keys from condition and value is coverage rate >>. + # ex: branches =>{ [:if, 3, 8, 6, 8, 36] => {[:then, 4, 8, 6, 8, 12] => 1, [:else, 5, 8, 6, 8, 36]=>2}, other conditions...} + # We create copy of result and update it values depending on the combined branches coverage values. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/branches_combiner.rb:23 + def combine(coverage_a, coverage_b); end + end +end + +# Handle combining two coverage results for same file +# +# Should be called through `SimpleCov.combine`. +# +# source://simplecov-0.21.2/lib/simplecov/combine/files_combiner.rb:9 +module SimpleCov::Combine::FilesCombiner + private + + # Combines the results for 2 coverages of a file. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/files_combiner.rb:17 + def combine(coverage_a, coverage_b); end + + class << self + # Combines the results for 2 coverages of a file. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/files_combiner.rb:17 + def combine(coverage_a, coverage_b); end + end +end + +# Combine two different lines coverage results on same file +# +# Should be called through `SimpleCov.combine`. +# +# source://simplecov-0.21.2/lib/simplecov/combine/lines_combiner.rb:9 +module SimpleCov::Combine::LinesCombiner + private + + # source://simplecov-0.21.2/lib/simplecov/combine/lines_combiner.rb:12 + def combine(coverage_a, coverage_b); end + + # Return depends on coverage in a specific line + # + # Logic: + # + # => nil + 0 = nil + # => nil + nil = nil + # => int + int = int + # + # @param first_val [Integer || nil] + # @param second_val [Integer || nil] + # @return [Integer || nil] + # + # source://simplecov-0.21.2/lib/simplecov/combine/lines_combiner.rb:32 + def merge_line_coverage(first_val, second_val); end + + class << self + # source://simplecov-0.21.2/lib/simplecov/combine/lines_combiner.rb:12 + def combine(coverage_a, coverage_b); end + + # Return depends on coverage in a specific line + # + # Logic: + # + # => nil + 0 = nil + # => nil + nil = nil + # => int + int = int + # + # @param first_val [Integer || nil] + # @param second_val [Integer || nil] + # @return [Integer || nil] + # + # source://simplecov-0.21.2/lib/simplecov/combine/lines_combiner.rb:32 + def merge_line_coverage(first_val, second_val); end + end +end + +# There might be reports from different kinds of tests, +# e.g. RSpec and Cucumber. We need to combine their results +# into unified one. This class does that. +# To unite the results on file basis, it leverages +# the combine of lines and branches inside each file within given results. +# +# source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:10 +module SimpleCov::Combine::ResultsCombiner + private + + # Combine process explanation + # => ResultCombiner: define all present files between results and start combine on file level. + # ==> FileCombiner: collect result of next combine levels lines and branches. + # ===> LinesCombiner: combine lines results. + # ===> BranchesCombiner: combine branches results. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:22 + def combine(*results); end + + # Combine two files coverage results + # + # @param coverage_a [Hash] + # @param coverage_b [Hash] + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:55 + def combine_file_coverage(coverage_a, coverage_b); end + + # Manage combining results on files level + # + # @param combined_results [Hash] + # @param result [Hash] + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:36 + def combine_result_sets(combined_results, result); end + + class << self + # Combine process explanation + # => ResultCombiner: define all present files between results and start combine on file level. + # ==> FileCombiner: collect result of next combine levels lines and branches. + # ===> LinesCombiner: combine lines results. + # ===> BranchesCombiner: combine branches results. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:22 + def combine(*results); end + + # Combine two files coverage results + # + # @param coverage_a [Hash] + # @param coverage_b [Hash] + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:55 + def combine_file_coverage(coverage_a, coverage_b); end + + # Manage combining results on files level + # + # @param combined_results [Hash] + # @param result [Hash] + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/combine/results_combiner.rb:36 + def combine_result_sets(combined_results, result); end + end +end + +# Helper that tries to find out what test suite is running (for SimpleCov.command_name) +# +# source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:7 +module SimpleCov::CommandGuesser + class << self + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:16 + def guess; end + + # Storage for the original command line call that invoked the test suite. + # This has got to be stored as early as possible because i.e. rake and test/unit 2 + # have a habit of tampering with ARGV, which makes i.e. the automatic distinction + # between rails unit/functional/integration tests impossible without this cached + # item. + # + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:14 + def original_run_command; end + + # Storage for the original command line call that invoked the test suite. + # This has got to be stored as early as possible because i.e. rake and test/unit 2 + # have a habit of tampering with ARGV, which makes i.e. the automatic distinction + # between rails unit/functional/integration tests impossible without this cached + # item. + # + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:14 + def original_run_command=(_arg0); end + + private + + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:31 + def from_command_line_options; end + + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:46 + def from_defined_constants; end + + # source://simplecov-0.21.2/lib/simplecov/command_guesser.rb:22 + def from_env; end + end +end + +# Bundles the configuration options used for SimpleCov. All methods +# defined here are usable from SimpleCov directly. Please check out +# SimpleCov documentation for further info. +# +# source://simplecov-0.21.2/lib/simplecov/configuration.rb:13 +module SimpleCov::Configuration + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:161 + def adapters; end + + # Add a filter to the processing chain. + # There are four ways to define a filter: + # + # * as a String that will then be matched against all source files' file paths, + # SimpleCov.add_filter 'app/models' # will reject all your models + # * as a block which will be passed the source file in question and should either + # return a true or false value, depending on whether the file should be removed + # SimpleCov.add_filter do |src_file| + # File.basename(src_file.filename) == 'environment.rb' + # end # Will exclude environment.rb files from the results + # * as an array of strings that are matched against all sorce files' file + # paths and then ignored (basically string filter multiple times) + # SimpleCov.add_filter ['app/models', 'app/helpers'] # ignores both dirs + # * as an instance of a subclass of SimpleCov::Filter. See the documentation there + # on how to define your own filter classes + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:367 + def add_filter(filter_argument = T.unsafe(nil), &filter_proc); end + + # Define a group for files. Works similar to add_filter, only that the first + # argument is the desired group name and files PASSING the filter end up in the group + # (while filters exclude when the filter is applicable). + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:376 + def add_group(group_name, filter_argument = T.unsafe(nil), &filter_proc); end + + # Gets or sets the behavior to process coverage results. + # + # By default, it will call SimpleCov.result.format! + # + # Configure with: + # + # SimpleCov.at_exit do + # puts "Coverage done" + # SimpleCov.result.format! + # end + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:193 + def at_exit(&block); end + + # Gets or sets the behavior to start a new forked Process. + # + # By default, it will add " (Process #{pid})" to the command_name, and start SimpleCov in quiet mode + # + # Configure with: + # + # SimpleCov.at_fork do |pid| + # SimpleCov.start do + # # This needs a unique name so it won't be ovewritten + # SimpleCov.command_name "#{SimpleCov.command_name} (subprocess: #{pid})" + # # be quiet, the parent process will be in charge of using the regular formatter and checking coverage totals + # SimpleCov.print_error_status = false + # SimpleCov.formatter SimpleCov::Formatter::SimpleFormatter + # SimpleCov.minimum_coverage 0 + # # start + # SimpleCov.start + # end + # end + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:233 + def at_fork(&block); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:428 + def branch_coverage?; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:432 + def branch_coverage_supported?; end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:424 + def clear_coverage_criteria; end + + # The name of the command (a.k.a. Test Suite) currently running. Used for result + # merging and caching. It first tries to make a guess based upon the command line + # arguments the current test suite is running on and should automatically detect + # unit tests, functional tests, integration tests, rpsec and cucumber and label + # them properly. If it fails to recognize the current command, the command name + # is set to the shell command that the current suite is running on. + # + # You can specify it manually with SimpleCov.command_name("test:units") - please + # also check out the corresponding section in README.rdoc + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:87 + def command_name(name = T.unsafe(nil)); end + + # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods + # you're calling. + # + # SimpleCov.configure do + # add_filter 'foobar' + # end + # + # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure + # options at once. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:177 + def configure(&block); end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:416 + def coverage_criteria; end + + # Define which coverage criterion should be evaluated. + # + # Possible coverage criteria: + # * :line - coverage based on lines aka has this line been executed? + # * :branch - coverage based on branches aka has this branch (think conditions) been executed? + # + # If not set the default is `:line` + # + # @param criterion [Symbol] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:393 + def coverage_criterion(criterion = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:420 + def coverage_criterion_enabled?(criterion); end + + # The name of the output and cache directory. Defaults to 'coverage' + # + # Configure with SimpleCov.coverage_dir('cov') + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:34 + def coverage_dir(dir = T.unsafe(nil)); end + + # Returns the full path to the output directory using SimpleCov.root + # and SimpleCov.coverage_dir, so you can adjust this by configuring those + # values. Will create the directory if it's missing + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:46 + def coverage_path; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:432 + def coverage_start_arguments_supported?; end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:401 + def enable_coverage(criterion); end + + # gets or sets the enabled_for_subprocess configuration + # when true, this will inject SimpleCov code into Process.fork + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:202 + def enable_for_subprocesses(value = T.unsafe(nil)); end + + # gets the enabled_for_subprocess configuration + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:209 + def enabled_for_subprocesses?; end + + # Returns the list of configured filters. Add filters using SimpleCov.add_filter. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:74 + def filters; end + + # Sets the attribute filters + # + # @param value the value to set the attribute filters to. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:14 + def filters=(_arg0); end + + # Gets or sets the configured formatter. + # + # Configure with: SimpleCov.formatter(SimpleCov::Formatter::SimpleFormatter) + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:98 + def formatter(formatter = T.unsafe(nil)); end + + # Sets the attribute formatter + # + # @param value the value to set the attribute formatter to. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:14 + def formatter=(_arg0); end + + # Gets the configured formatters. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:117 + def formatters; end + + # Sets the configured formatters. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:110 + def formatters=(formatters); end + + # Returns the configured groups. Add groups using SimpleCov.add_group + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:150 + def groups; end + + # Sets the attribute groups + # + # @param value the value to set the attribute groups to. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:14 + def groups=(_arg0); end + + # Defines the maximum coverage drop at once allowed for the testsuite to pass. + # SimpleCov will return non-zero if the coverage decreases by more than this threshold. + # + # Default is 100% (disabled) + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:313 + def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end + + # Defines the maximum age (in seconds) of a resultset to still be included in merged results. + # i.e. If you run cucumber features, then later rake test, if the stored cucumber resultset is + # more seconds ago than specified here, it won't be taken into account when merging (and is also + # purged from the resultset cache) + # + # Of course, this only applies when merging is active (e.g. SimpleCov.use_merging is not false!) + # + # Default is 600 seconds (10 minutes) + # + # Configure with SimpleCov.merge_timeout(3600) # 1hr + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:279 + def merge_timeout(seconds = T.unsafe(nil)); end + + # Defines the minimum overall coverage required for the testsuite to pass. + # SimpleCov will return non-zero if the current coverage is below this threshold. + # + # Default is 0% (disabled) + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:290 + def minimum_coverage(coverage = T.unsafe(nil)); end + + # Defines the minimum coverage per file required for the testsuite to pass. + # SimpleCov will return non-zero if the current coverage of the least covered file + # is below this threshold. + # + # Default is 0% (disabled) + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:330 + def minimum_coverage_by_file(coverage = T.unsafe(nil)); end + + # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from + # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token + # can be configured to be any other string using this. + # + # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip') + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:140 + def nocov_token(nocov_token = T.unsafe(nil)); end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:407 + def primary_coverage(criterion = T.unsafe(nil)); end + + # Whether we should print non-success status codes. This can be + # configured with the #print_error_status= method. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:129 + def print_error_status; end + + # Sets the attribute print_error_status + # + # @param value the value to set the attribute print_error_status to. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:14 + def print_error_status=(_arg0); end + + # Returns the hash of available profiles + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:157 + def profiles; end + + # Returns the project name - currently assuming the last dirname in + # the SimpleCov.root is this. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:251 + def project_name(new_name = T.unsafe(nil)); end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:300 + def raise_on_invalid_coverage(coverage, coverage_setting); end + + # Refuses any coverage drop. That is, coverage is only allowed to increase. + # SimpleCov will return non-zero if the coverage decreases. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:344 + def refuse_coverage_drop(*criteria); end + + # The root for the project. This defaults to the + # current working directory. + # + # Configure with SimpleCov.root('/my/project/path') + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:22 + def root(root = T.unsafe(nil)); end + + # Certain code blocks (i.e. Ruby-implementation specific code) can be excluded from + # the coverage metrics by wrapping it inside # :nocov: comment blocks. The nocov token + # can be configured to be any other string using this. + # + # Configure with SimpleCov.nocov_token('skip') or it's alias SimpleCov.skip_token('skip') + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:140 + def skip_token(nocov_token = T.unsafe(nil)); end + + # Coverage results will always include files matched by this glob, whether + # or not they were explicitly required. Without this, un-required files + # will not be present in the final report. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:59 + def track_files(glob); end + + # Returns the glob that will be used to include files that were not + # explicitly required. + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:67 + def tracked_files; end + + # Defines whether to use result merging so all your test suites (test:units, test:functionals, cucumber, ...) + # are joined and combined into a single coverage report + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:262 + def use_merging(use = T.unsafe(nil)); end + + private + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:464 + def minimum_possible_coverage_exceeded(coverage_option); end + + # The actual filter processor. Not meant for direct use + # + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:471 + def parse_filter(filter_argument = T.unsafe(nil), &filter_proc); end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:447 + def raise_if_criterion_disabled(criterion); end + + # source://simplecov-0.21.2/lib/simplecov/configuration.rb:456 + def raise_if_criterion_unsupported(criterion); end +end + +# source://simplecov-0.21.2/lib/simplecov/configuration.rb:381 +SimpleCov::Configuration::DEFAULT_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol) + +# source://simplecov-0.21.2/lib/simplecov/configuration.rb:380 +SimpleCov::Configuration::SUPPORTED_COVERAGE_CRITERIA = T.let(T.unsafe(nil), Array) + +# Holds the individual data of a coverage result. +# +# This is uniform across coverage criteria as they all have: +# +# * total - how many things to cover there are (total relevant loc/branches) +# * covered - how many of the coverables are hit +# * missed - how many of the coverables are missed +# * percent - percentage as covered/missed +# * strength - average hits per/coverable (will not exist for one shot lines format) +# +# source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:13 +class SimpleCov::CoverageStatistics + # Requires only covered, missed and strength to be initialized. + # + # Other values are computed by this class. + # + # @return [CoverageStatistics] a new instance of CoverageStatistics + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:34 + def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end + + # Returns the value of attribute covered. + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:14 + def covered; end + + # Returns the value of attribute missed. + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:14 + def missed; end + + # Returns the value of attribute percent. + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:14 + def percent; end + + # Returns the value of attribute strength. + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:14 + def strength; end + + # Returns the value of attribute total. + # + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:14 + def total; end + + private + + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:44 + def compute_percent(covered, missed, total); end + + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:50 + def compute_strength(total_strength, total); end + + class << self + # source://simplecov-0.21.2/lib/simplecov/coverage_statistics.rb:16 + def from(coverage_statistics); end + end +end + +# source://simplecov-0.21.2/lib/simplecov/exit_codes.rb:4 +module SimpleCov::ExitCodes; end + +# source://simplecov-0.21.2/lib/simplecov/exit_codes.rb:6 +SimpleCov::ExitCodes::EXCEPTION = T.let(T.unsafe(nil), Integer) + +# source://simplecov-0.21.2/lib/simplecov/exit_codes/exit_code_handling.rb:5 +module SimpleCov::ExitCodes::ExitCodeHandling + private + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/exit_code_handling.rb:8 + def call(result, coverage_limits:); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/exit_code_handling.rb:20 + def coverage_checks(result, coverage_limits); end + + class << self + # source://simplecov-0.21.2/lib/simplecov/exit_codes/exit_code_handling.rb:8 + def call(result, coverage_limits:); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/exit_code_handling.rb:20 + def coverage_checks(result, coverage_limits); end + end +end + +# source://simplecov-0.21.2/lib/simplecov/exit_codes.rb:8 +SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP = T.let(T.unsafe(nil), Integer) + +# source://simplecov-0.21.2/lib/simplecov/exit_codes.rb:7 +SimpleCov::ExitCodes::MINIMUM_COVERAGE = T.let(T.unsafe(nil), Integer) + +# source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:5 +class SimpleCov::ExitCodes::MaximumCoverageDropCheck + # @return [MaximumCoverageDropCheck] a new instance of MaximumCoverageDropCheck + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:6 + def initialize(result, maximum_coverage_drop); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:28 + def exit_code; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:11 + def failing?; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:17 + def report; end + + private + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:49 + def compute_coverage_drop_data; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:42 + def coverage_drop_violations; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:61 + def drop_percent(criterion); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:73 + def last_coverage(criterion); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:36 + def last_run; end + + # Returns the value of attribute maximum_coverage_drop. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:34 + def maximum_coverage_drop; end + + # Returns the value of attribute result. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:34 + def result; end +end + +# if anyone says "max_coverage_drop 0.000000000000000001" I appologize. Please don't. +# +# source://simplecov-0.21.2/lib/simplecov/exit_codes/maximum_coverage_drop_check.rb:60 +SimpleCov::ExitCodes::MaximumCoverageDropCheck::MAX_DROP_ACCURACY = T.let(T.unsafe(nil), Integer) + +# source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:5 +class SimpleCov::ExitCodes::MinimumCoverageByFileCheck + # @return [MinimumCoverageByFileCheck] a new instance of MinimumCoverageByFileCheck + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:6 + def initialize(result, minimum_coverage_by_file); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:26 + def exit_code; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:11 + def failing?; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:15 + def report; end + + private + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:41 + def compute_minimum_coverage_data; end + + # Returns the value of attribute minimum_coverage_by_file. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:32 + def minimum_coverage_by_file; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:34 + def minimum_violations; end + + # Returns the value of attribute result. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb:32 + def result; end +end + +# source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:5 +class SimpleCov::ExitCodes::MinimumOverallCoverageCheck + # @return [MinimumOverallCoverageCheck] a new instance of MinimumOverallCoverageCheck + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:6 + def initialize(result, minimum_coverage); end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:26 + def exit_code; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:11 + def failing?; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:15 + def report; end + + private + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:38 + def calculate_minimum_violations; end + + # Returns the value of attribute minimum_coverage. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:32 + def minimum_coverage; end + + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:34 + def minimum_violations; end + + # Returns the value of attribute result. + # + # source://simplecov-0.21.2/lib/simplecov/exit_codes/minimum_overall_coverage_check.rb:32 + def result; end +end + +# source://simplecov-0.21.2/lib/simplecov/exit_codes.rb:5 +SimpleCov::ExitCodes::SUCCESS = T.let(T.unsafe(nil), Integer) + +# An array of SimpleCov SourceFile instances with additional collection helper +# methods for calculating coverage across them etc. +# +# source://simplecov-0.21.2/lib/simplecov/file_list.rb:6 +class SimpleCov::FileList + include ::Enumerable + extend ::Forwardable + + # @return [FileList] a new instance of FileList + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:22 + def initialize(files); end + + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:101 + def branch_covered_percent; end + + # source://RUBY_ROOT/forwardable.rb:226 + def count(*args, &block); end + + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:26 + def coverage_statistics; end + + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:30 + def coverage_statistics_by_file; end + + # Return total count of covered branches + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:92 + def covered_branches; end + + # Returns the count of lines that have coverage + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:35 + def covered_lines; end + + # Computes the coverage based upon lines covered and lines missed + # + # @return [Float] + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:76 + def covered_percent; end + + # Computes the coverage based upon lines covered and lines missed for each file + # Returns an array with all coverage percentages + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:60 + def covered_percentages; end + + # Computes the strength (hits / line) based upon lines covered and lines missed + # + # @return [Float] + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:82 + def covered_strength; end + + # source://RUBY_ROOT/forwardable.rb:226 + def each(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def empty?(*args, &block); end + + # Finds the least covered file and returns that file's name + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:65 + def least_covered_file; end + + # source://RUBY_ROOT/forwardable.rb:226 + def length(*args, &block); end + + # Returns the overall amount of relevant lines of code across all files in this list + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:70 + def lines_of_code; end + + # source://RUBY_ROOT/forwardable.rb:226 + def map(*args, &block); end + + # Return total count of covered branches + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:97 + def missed_branches; end + + # Returns the count of lines that have been missed + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:40 + def missed_lines; end + + # Returns the count of lines that are not relevant for coverage + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:45 + def never_lines; end + + # source://RUBY_ROOT/forwardable.rb:226 + def size(*args, &block); end + + # Returns the count of skipped lines + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:52 + def skipped_lines; end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_a(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def to_ary(*args, &block); end + + # Return total count of branches in all files + # + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:87 + def total_branches; end + + private + + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:114 + def compute_coverage_statistics; end + + # source://simplecov-0.21.2/lib/simplecov/file_list.rb:107 + def compute_coverage_statistics_by_file; end +end + +# Base filter class. Inherit from this to create custom filters, +# and overwrite the passes?(source_file) instance method +# +# # A sample class that rejects all source files. +# class StupidFilter < SimpleCov::Filter +# def passes?(source_file) +# false +# end +# end +# +# source://simplecov-0.21.2/lib/simplecov/filter.rb:15 +class SimpleCov::Filter + # @return [Filter] a new instance of Filter + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:18 + def initialize(filter_argument); end + + # Returns the value of attribute filter_argument. + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:16 + def filter_argument; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:22 + def matches?(_source_file); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:26 + def passes?(source_file); end + + class << self + # source://simplecov-0.21.2/lib/simplecov/filter.rb:31 + def build_filter(filter_argument); end + + # source://simplecov-0.21.2/lib/simplecov/filter.rb:37 + def class_for_argument(filter_argument); end + end +end + +# TODO: Documentation on how to build your own formatters +# +# source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:4 +module SimpleCov::Formatter + class << self + # source://simplecov-0.21.2/lib/simplecov/default_formatter.rb:7 + def from_env(env); end + end +end + +# source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:5 +class SimpleCov::Formatter::MultiFormatter + class << self + # source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:26 + def [](*args); end + + # source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:17 + def new(formatters = T.unsafe(nil)); end + end +end + +# source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:6 +module SimpleCov::Formatter::MultiFormatter::InstanceMethods + # source://simplecov-0.21.2/lib/simplecov/formatter/multi_formatter.rb:7 + def format(result); end +end + +# A ridiculously simple formatter for SimpleCov results. +# +# source://simplecov-0.21.2/lib/simplecov/formatter/simple_formatter.rb:8 +class SimpleCov::Formatter::SimpleFormatter + # Takes a SimpleCov::Result and generates a string out of it + # + # source://simplecov-0.21.2/lib/simplecov/formatter/simple_formatter.rb:10 + def format(result); end +end + +# source://simplecov-0.21.2/lib/simplecov/last_run.rb:6 +module SimpleCov::LastRun + class << self + # source://simplecov-0.21.2/lib/simplecov/last_run.rb:8 + def last_run_path; end + + # source://simplecov-0.21.2/lib/simplecov/last_run.rb:12 + def read; end + + # source://simplecov-0.21.2/lib/simplecov/last_run.rb:21 + def write(json); end + end +end + +# Classifies whether lines are relevant for code coverage analysis. +# Comments & whitespace lines, and :nocov: token blocks, are considered not relevant. +# +# source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:7 +class SimpleCov::LinesClassifier + # source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:33 + def classify(lines); end + + class << self + # source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:15 + def no_cov_line; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:19 + def no_cov_line?(line); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:26 + def whitespace_line?(line); end + end +end + +# source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:12 +SimpleCov::LinesClassifier::COMMENT_LINE = T.let(T.unsafe(nil), Regexp) + +# source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:8 +SimpleCov::LinesClassifier::RELEVANT = T.let(T.unsafe(nil), Integer) + +# source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:11 +SimpleCov::LinesClassifier::WHITESPACE_LINE = T.let(T.unsafe(nil), Regexp) + +# source://simplecov-0.21.2/lib/simplecov/lines_classifier.rb:13 +SimpleCov::LinesClassifier::WHITESPACE_OR_COMMENT_LINE = T.let(T.unsafe(nil), Regexp) + +# Profiles are SimpleCov configuration procs that can be easily +# loaded using SimpleCov.start :rails and defined using +# SimpleCov.profiles.define :foo do +# # SimpleCov configuration here, same as in SimpleCov.configure +# end +# +# source://simplecov-0.21.2/lib/simplecov/profiles.rb:17 +class SimpleCov::Profiles < ::Hash + # Define a SimpleCov profile: + # SimpleCov.profiles.define 'rails' do + # # Same as SimpleCov.configure do .. here + # end + # + # source://simplecov-0.21.2/lib/simplecov/profiles.rb:18 + def define(name, &blk); end + + # Applies the profile of given name on SimpleCov.configure + # + # source://simplecov-0.21.2/lib/simplecov/profiles.rb:28 + def load(name); end +end + +# source://simplecov-0.21.2/lib/simplecov/filter.rb:63 +class SimpleCov::RegexFilter < ::SimpleCov::Filter + # Returns true when the given source file's filename matches the + # regex configured when initializing this Filter with RegexFilter.new(/someregex/) + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:64 + def matches?(source_file); end +end + +# A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage +# library generates (Coverage.result). +# +# source://simplecov-0.21.2/lib/simplecov/result.rb:11 +class SimpleCov::Result + extend ::Forwardable + + # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of + # coverage data) + # + # @return [Result] a new instance of Result + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:28 + def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil)); end + + # The command name that launched this result. + # Delegated to SimpleCov.command_name if not set manually + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:61 + def command_name; end + + # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:21 + def command_name=(_arg0); end + + # source://RUBY_ROOT/forwardable.rb:226 + def coverage_statistics(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def coverage_statistics_by_file(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def covered_branches(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def covered_lines(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def covered_percent(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def covered_percentages(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def covered_strength(*args, &block); end + + # Defines when this result has been created. Defaults to Time.now + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:55 + def created_at; end + + # Explicitly set the Time this result has been created + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:19 + def created_at=(_arg0); end + + # Returns all filenames for source files contained in this result + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:40 + def filenames; end + + # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:16 + def files; end + + # Applies the configured SimpleCov.formatter on this result + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:50 + def format!; end + + # Returns a Hash of groups for this result. Define groups using SimpleCov.add_group 'Models', 'app/models' + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:45 + def groups; end + + # source://RUBY_ROOT/forwardable.rb:226 + def least_covered_file(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def missed_branches(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def missed_lines(*args, &block); end + + # Returns the original Coverage.result used for this instance of SimpleCov::Result + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:14 + def original_result; end + + # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:16 + def source_files; end + + # Returns a hash representation of this Result that can be used for marshalling it into JSON + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:66 + def to_hash; end + + # source://RUBY_ROOT/forwardable.rb:226 + def total_branches(*args, &block); end + + # source://RUBY_ROOT/forwardable.rb:226 + def total_lines(*args, &block); end + + private + + # source://simplecov-0.21.2/lib/simplecov/result.rb:84 + def coverage; end + + # Applies all configured SimpleCov filters on this result's source files + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:90 + def filter!; end + + class << self + # Loads a SimpleCov::Result#to_hash dump + # + # source://simplecov-0.21.2/lib/simplecov/result.rb:76 + def from_hash(hash); end + end +end + +# Responsible for adapting the format of the coverage result whether it's default or with statistics +# +# source://simplecov-0.21.2/lib/simplecov/result_adapter.rb:7 +class SimpleCov::ResultAdapter + # @return [ResultAdapter] a new instance of ResultAdapter + # + # source://simplecov-0.21.2/lib/simplecov/result_adapter.rb:10 + def initialize(result); end + + # source://simplecov-0.21.2/lib/simplecov/result_adapter.rb:18 + def adapt; end + + # Returns the value of attribute result. + # + # source://simplecov-0.21.2/lib/simplecov/result_adapter.rb:8 + def result; end + + class << self + # source://simplecov-0.21.2/lib/simplecov/result_adapter.rb:14 + def call(*args); end + end +end + +# Singleton that is responsible for caching, loading and merging +# SimpleCov::Results into a single result for coverage analysis based +# upon multiple test suites. +# +# source://simplecov-0.21.2/lib/simplecov/result_merger.rb:11 +module SimpleCov::ResultMerger + class << self + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:187 + def adapt_pre_simplecov_0_18_result(result); end + + # We changed the format of the raw result data in simplecov, as people are likely + # to have "old" resultsets lying around (but not too old so that they're still + # considered we can adapt them). + # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747 + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:172 + def adapt_result(result); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:93 + def create_result(command_names, coverage); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:22 + def merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:100 + def merge_coverage(*results); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:28 + def merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:74 + def merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end + + # Gets all SimpleCov::Results stored in resultset, merges them and produces a new + # SimpleCov::Result with merged coverage data and the command_name + # for the result consisting of a join on all source result's names + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:117 + def merged_result; end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:51 + def parse_file(path); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:65 + def parse_json(content); end + + # pre 0.18 coverage data pointed from file directly to an array of line coverage + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:181 + def pre_simplecov_0_18_result?(result); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:56 + def read_file(path); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:126 + def read_resultset; end + + # The path to the .resultset.json cache file + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:14 + def resultset_path; end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:18 + def resultset_writelock; end + + # Saves the given SimpleCov::Result in the resultset cache + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:136 + def store_result(result); end + + # Ensure only one process is reading or writing the resultset at any + # given time + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:153 + def synchronize_resultset; end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:89 + def time_since_result_creation(data); end + + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:46 + def valid_results(file_path, ignore_timeout: T.unsafe(nil)); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/result_merger.rb:85 + def within_merge_timeout?(data); end + end +end + +# Responsible for producing file coverage metrics. +# +# source://simplecov-0.21.2/lib/simplecov/simulate_coverage.rb:7 +module SimpleCov::SimulateCoverage + private + + # Simulate normal file coverage report on + # ruby 2.5 and return similar hash with lines and branches keys + # + # Happens when a file wasn't required but still tracked. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/simulate_coverage.rb:18 + def call(absolute_path); end + + class << self + # Simulate normal file coverage report on + # ruby 2.5 and return similar hash with lines and branches keys + # + # Happens when a file wasn't required but still tracked. + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/simulate_coverage.rb:18 + def call(absolute_path); end + end +end + +# Representation of a source file including it's coverage data, source code, +# source lines and featuring helpers to interpret that data. +# +# source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:4 +class SimpleCov::SourceFile + # @return [SourceFile] a new instance of SourceFile + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:14 + def initialize(filename, coverage_data); end + + # Return all the branches inside current source file + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:98 + def branches; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:106 + def branches_coverage_percent; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:142 + def branches_for_line(line_number); end + + # Return hash with key of line number and branch coverage count as value + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:118 + def branches_report; end + + # The array of coverage data received from the Coverage.result + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:12 + def coverage_data; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:32 + def coverage_statistics; end + + # Select the covered branches + # Here we user tree schema because some conditions like case may have additional + # else that is not in declared inside the code but given by default by coverage report + # + # @return [Array] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:129 + def covered_branches; end + + # Returns all covered lines as SimpleCov::SourceFile::Line + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:48 + def covered_lines; end + + # The coverage for this file in percent. 0 if the file has no coverage lines + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:80 + def covered_percent; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:84 + def covered_strength; end + + # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb) + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:10 + def filename; end + + # Access SimpleCov::SourceFile::Line source lines by line number + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:75 + def line(number); end + + # Check if any branches missing on given line number + # + # @param line_number [Integer] + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:153 + def line_with_missed_branch?(line_number); end + + # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line, + # and thus including coverage data. Aliased as :source_lines + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:42 + def lines; end + + # Returns the number of relevant lines (covered + missed) + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:70 + def lines_of_code; end + + # Select the missed branches with coverage equal to zero + # + # @return [Array] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:138 + def missed_branches; end + + # Returns all lines that should have been, but were not covered + # as instances of SimpleCov::SourceFile::Line + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:54 + def missed_lines; end + + # Returns all lines that are not relevant for coverage as + # SimpleCov::SourceFile::Line instances + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:60 + def never_lines; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:102 + def no_branches?; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:88 + def no_lines?; end + + # The path to this source file relative to the projects directory + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:20 + def project_filename; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:92 + def relevant_lines; end + + # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:65 + def skipped_lines; end + + # The source code for this file. Aliased as :source + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:25 + def source; end + + # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line, + # and thus including coverage data. Aliased as :source_lines + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:42 + def source_lines; end + + # The source code for this file. Aliased as :source + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:25 + def src; end + + # Return the relevant branches to source file + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:112 + def total_branches; end + + private + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:340 + def branch_coverage_statistics; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:318 + def build_branch(branch_data, hit_count, condition_start_line); end + + # Call recursive method that transform our static hash to array of objects + # + # @return [Array] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:267 + def build_branches; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:304 + def build_branches_from(condition, branches); end + + # Build full branches report + # Root branches represent the wrapper of all condition state that + # have inside the branches + # + # @return [Hash] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:256 + def build_branches_report; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:223 + def build_lines; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:164 + def build_no_cov_chunks; end + + # Warning to identify condition from Issue #56 + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:245 + def coverage_exceeding_source_warn; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:214 + def ensure_remove_undefs(file_lines); end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:330 + def line_coverage_statistics; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:240 + def lines_strength; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:178 + def load_source; end + + # no_cov_chunks is zero indexed to work directly with the array holding the lines + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:160 + def no_cov_chunks; end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:276 + def process_skipped_branches(branches); end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:231 + def process_skipped_lines(lines); end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:198 + def read_lines(file, lines, current_line); end + + # Since we are dumping to and loading from JSON, and we have arrays as keys those + # don't make their way back to us intact e.g. just as a string + # + # We should probably do something different here, but as it stands these are + # our data structures that we write so eval isn't _too_ bad. + # + # See #801 + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:294 + def restore_ruby_data_structure(structure); end + + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:206 + def set_encoding_based_on_magic_comment(file, line); end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file.rb:194 + def shebang?(line); end +end + +# Representing single branch that has been detected in coverage report. +# Give us support methods that handle needed calculations. +# +# source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:8 +class SimpleCov::SourceFile::Branch + # @return [Branch] a new instance of Branch + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:12 + def initialize(start_line:, end_line:, coverage:, inline:, type:); end + + # Returns the value of attribute coverage. + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:9 + def coverage; end + + # Return true if there is relevant count defined > 0 + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:31 + def covered?; end + + # Returns the value of attribute end_line. + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:9 + def end_line; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:22 + def inline?; end + + # Check if branche missed or not + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:40 + def missed?; end + + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:70 + def overlaps_with?(line_range); end + + # Return array with coverage count and badge + # + # @return [Array] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:79 + def report; end + + # The line on which we want to report the coverage + # + # Usually we choose the line above the start of the branch (so that it shows up + # at if/else) because that + # * highlights the condition + # * makes it distinguishable if the first line of the branch is an inline branch + # (see the nested_branches fixture) + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:52 + def report_line; end + + # Flags the branch as skipped + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:61 + def skipped!; end + + # Returns true if the branch was marked skipped by virtue of nocov comments. + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:66 + def skipped?; end + + # Returns the value of attribute start_line. + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:9 + def start_line; end + + # Returns the value of attribute type. + # + # source://simplecov-0.21.2/lib/simplecov/source_file/branch.rb:9 + def type; end +end + +# Representation of a single line in a source file including +# this specific line's source code, line_number and code coverage, +# with the coverage being either nil (coverage not applicable, e.g. comment +# line), 0 (line not covered) or >1 (the amount of times the line was +# executed) +# +# source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:10 +class SimpleCov::SourceFile::Line + # @raise [ArgumentError] + # @return [Line] a new instance of Line + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:25 + def initialize(src, line_number, coverage); end + + # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered) + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:16 + def coverage; end + + # Returns true if this is a line that has been covered + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:42 + def covered?; end + + # The line number in the source file. Aliased as :line, :number + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:14 + def line; end + + # The line number in the source file. Aliased as :line, :number + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:14 + def line_number; end + + # Returns true if this is a line that should have been covered, but was not + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:37 + def missed?; end + + # Returns true if this line is not relevant for coverage + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:47 + def never?; end + + # The line number in the source file. Aliased as :line, :number + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:14 + def number; end + + # Whether this line was skipped + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:18 + def skipped; end + + # Flags this line as skipped + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:52 + def skipped!; end + + # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with + # # :nocov: comment lines. + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:58 + def skipped?; end + + # The source code for this line. Aliased as :source + # Lets grab some fancy aliases, shall we? + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:12 + def source; end + + # The source code for this line. Aliased as :source + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:12 + def src; end + + # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use + # as a css class in report generation + # + # source://simplecov-0.21.2/lib/simplecov/source_file/line.rb:64 + def status; end +end + +# source://simplecov-0.21.2/lib/simplecov/source_file.rb:205 +SimpleCov::SourceFile::RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://simplecov-0.21.2/lib/simplecov/source_file.rb:193 +SimpleCov::SourceFile::SHEBANG_REGEX = T.let(T.unsafe(nil), Regexp) + +# source://simplecov-0.21.2/lib/simplecov/filter.rb:55 +class SimpleCov::StringFilter < ::SimpleCov::Filter + # Returns true when the given source file's filename matches the + # string configured when initializing this Filter with StringFilter.new('somestring') + # + # @return [Boolean] + # + # source://simplecov-0.21.2/lib/simplecov/filter.rb:56 + def matches?(source_file); end +end + +# Select the files that related to working scope directory of SimpleCov +# +# source://simplecov-0.21.2/lib/simplecov/useless_results_remover.rb:7 +module SimpleCov::UselessResultsRemover + class << self + # source://simplecov-0.21.2/lib/simplecov/useless_results_remover.rb:8 + def call(coverage_result); end + + # source://simplecov-0.21.2/lib/simplecov/useless_results_remover.rb:14 + def root_regx; end + end +end + +# source://simplecov-0.21.2/lib/simplecov/version.rb:4 +SimpleCov::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/simplecov_json_formatter.rbi b/sorbet/rbi/gems/simplecov_json_formatter.rbi deleted file mode 100644 index 02100cac..00000000 --- a/sorbet/rbi/gems/simplecov_json_formatter.rbi +++ /dev/null @@ -1,47 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/simplecov_json_formatter/all/simplecov_json_formatter.rbi -# -# simplecov_json_formatter-0.1.4 - -module SimpleCovJSONFormatter -end -class SimpleCovJSONFormatter::SourceFileFormatter - def branch_coverage; end - def branches; end - def format; end - def initialize(source_file); end - def line_coverage; end - def lines; end - def parse_branch(branch); end - def parse_line(line); end -end -class SimpleCovJSONFormatter::ResultHashFormatter - def format; end - def format_files; end - def format_groups; end - def format_source_file(source_file); end - def formatted_result; end - def initialize(result); end -end -class SimpleCovJSONFormatter::ResultExporter - def export; end - def export_path; end - def initialize(result_hash); end - def json_result; end -end -module SimpleCov -end -module SimpleCov::Formatter -end -class SimpleCov::Formatter::JSONFormatter - def export_formatted_result(result_hash); end - def format(result); end - def format_result(result); end - def output_message(result); end -end diff --git a/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi b/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi new file mode 100644 index 00000000..4b5c6ae5 --- /dev/null +++ b/sorbet/rbi/gems/simplecov_json_formatter@0.1.4.rbi @@ -0,0 +1,8 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `simplecov_json_formatter` gem. +# Please instead update this file by running `bin/tapioca gem simplecov_json_formatter`. + +# THIS IS AN EMPTY RBI FILE. +# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem diff --git a/sorbet/rbi/gems/spoom@1.1.12.rbi b/sorbet/rbi/gems/spoom@1.1.12.rbi new file mode 100644 index 00000000..c08d749b --- /dev/null +++ b/sorbet/rbi/gems/spoom@1.1.12.rbi @@ -0,0 +1,2369 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `spoom` gem. +# Please instead update this file by running `bin/tapioca gem spoom`. + +# source://spoom-1.1.12/lib/spoom.rb:7 +module Spoom + class << self + # source://spoom-1.1.12/lib/spoom.rb:45 + sig { params(cmd: ::String, arg: ::String, path: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) } + def exec(cmd, *arg, path: T.unsafe(nil), capture_err: T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/cli/helper.rb:9 +module Spoom::Cli; end + +# source://spoom-1.1.12/lib/spoom/cli/bump.rb:9 +class Spoom::Cli::Bump < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + # source://spoom-1.1.12/lib/spoom/cli/bump.rb:32 + sig { params(directory: ::String).void } + def bump(directory = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/bump.rb:159 + def config_files(path: T.unsafe(nil)); end + + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/bump.rb:134 + def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/bump.rb:155 + def undo_changes(files, from_strictness); end +end + +# source://spoom-1.1.12/lib/spoom/cli/config.rb:9 +class Spoom::Cli::Config < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/config.rb:15 + def show; end +end + +# source://spoom-1.1.12/lib/spoom/cli/coverage.rb:9 +class Spoom::Cli::Coverage < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:187 + def bundle_install(path, sha); end + + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:199 + def message_no_data(file); end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:162 + def open(file = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:178 + def parse_time(string, option); end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:131 + def report; end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:20 + def snapshot; end + + # source://spoom-1.1.12/lib/spoom/cli/coverage.rb:43 + def timeline; end +end + +# source://spoom-1.1.12/lib/spoom/cli/coverage.rb:12 +Spoom::Cli::Coverage::DATA_DIR = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/cli/helper.rb:10 +module Spoom::Cli::Helper + include ::Spoom::Colorize + + requires_ancestor { Thor } + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:143 + sig { params(string: ::String).returns(::String) } + def blue(string); end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:87 + sig { params(exit_code: ::Integer, block: T.nilable(T.proc.void)).void } + def check_sorbet_segfault(exit_code, &block); end + + # Is the `--color` option true? + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:107 + sig { returns(T::Boolean) } + def color?; end + + # Colorize a string if `color?` + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:136 + sig { params(string: ::String, color: ::Spoom::Color).returns(::String) } + def colorize(string, *color); end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:148 + sig { params(string: ::String).returns(::String) } + def cyan(string); end + + # Return the path specified through `--path` + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:72 + sig { returns(::String) } + def exec_path; end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:153 + sig { params(string: ::String).returns(::String) } + def gray(string); end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:158 + sig { params(string: ::String).returns(::String) } + def green(string); end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:112 + sig { params(string: ::String).returns(::String) } + def highlight(string); end + + # Enforce that `spoom` is ran inside a project with a `sorbet/config` file + # + # Display an error message and exit otherwise. + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:59 + sig { void } + def in_sorbet_project!; end + + # Is `spoom` ran inside a project with a `sorbet/config` file? + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:51 + sig { returns(T::Boolean) } + def in_sorbet_project?; end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:163 + sig { params(string: ::String).returns(::String) } + def red(string); end + + # Print `message` on `$stdout` + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:20 + sig { params(message: ::String).void } + def say(message); end + + # Print `message` on `$stderr` + # + # The message is prefixed by a status (default: `Error`). + # + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:39 + sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void } + def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:82 + sig { returns(::Spoom::Sorbet::Config) } + def sorbet_config; end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:77 + sig { returns(::String) } + def sorbet_config_file; end + + # source://spoom-1.1.12/lib/spoom/cli/helper.rb:168 + sig { params(string: ::String).returns(::String) } + def yellow(string); end +end + +# source://spoom-1.1.12/lib/spoom/cli/lsp.rb:10 +class Spoom::Cli::LSP < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:54 + def defs(file, line, col); end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:64 + def find(query); end + + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:40 + def hover(file, line, col); end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:25 + def list; end + + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:113 + def lsp_client; end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:84 + def refs(file, line, col); end + + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:135 + def run(&block); end + + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:16 + def show; end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:94 + def sigs(file, line, col); end + + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:127 + def symbol_printer; end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:74 + def symbols(file); end + + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:160 + def to_uri(path); end + + # TODO: options, filter, limit, kind etc.. filter rbi + # + # source://spoom-1.1.12/lib/spoom/cli/lsp.rb:104 + def types(file, line, col); end +end + +# source://spoom-1.1.12/lib/spoom/cli.rb:16 +class Spoom::Cli::Main < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + # source://spoom-1.1.12/lib/spoom/cli.rb:68 + def __print_version; end + + # source://thor-1.2.1/lib/thor.rb:239 + def bump(*args); end + + # source://thor-1.2.1/lib/thor.rb:239 + def config(*args); end + + # source://thor-1.2.1/lib/thor.rb:239 + def coverage(*args); end + + # source://spoom-1.1.12/lib/spoom/cli.rb:43 + def files; end + + # source://thor-1.2.1/lib/thor.rb:239 + def lsp(*args); end + + # source://thor-1.2.1/lib/thor.rb:239 + def tc(*args); end + + class << self + # @return [Boolean] + # + # source://spoom-1.1.12/lib/spoom/cli.rb:75 + def exit_on_failure?; end + end +end + +# source://spoom-1.1.12/lib/spoom/cli/run.rb:6 +class Spoom::Cli::Run < ::Thor + include ::Spoom::Colorize + include ::Spoom::Cli::Helper + + # source://spoom-1.1.12/lib/spoom/cli/run.rb:117 + def colorize_message(message); end + + # source://spoom-1.1.12/lib/spoom/cli/run.rb:108 + def format_error(error, format); end + + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/cli/run.rb:26 + def tc(*paths_to_select); end +end + +# source://spoom-1.1.12/lib/spoom/cli/run.rb:15 +Spoom::Cli::Run::DEFAULT_FORMAT = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/cli/run.rb:11 +Spoom::Cli::Run::SORT_CODE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/cli/run.rb:13 +Spoom::Cli::Run::SORT_ENUM = T.let(T.unsafe(nil), Array) + +# source://spoom-1.1.12/lib/spoom/cli/run.rb:12 +Spoom::Cli::Run::SORT_LOC = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/colors.rb:5 +class Spoom::Color < ::T::Enum + enums do + CLEAR = new + BOLD = new + BLACK = new + RED = new + GREEN = new + YELLOW = new + BLUE = new + MAGENTA = new + CYAN = new + WHITE = new + LIGHT_BLACK = new + LIGHT_RED = new + LIGHT_GREEN = new + LIGHT_YELLOW = new + LIGHT_BLUE = new + LIGHT_MAGENTA = new + LIGHT_CYAN = new + LIGHT_WHITE = new + end + + # source://spoom-1.1.12/lib/spoom/colors.rb:32 + sig { returns(::String) } + def ansi_code; end +end + +# source://spoom-1.1.12/lib/spoom/colors.rb:37 +module Spoom::Colorize + # source://spoom-1.1.12/lib/spoom/colors.rb:41 + sig { params(string: ::String, color: ::Spoom::Color).returns(::String) } + def set_color(string, *color); end +end + +# An abstraction to a Ruby project context +# +# A context maps to a directory in the file system. +# It is used to manipulate files and run commands in the context of this directory. +# +# source://spoom-1.1.12/lib/spoom/context.rb:12 +class Spoom::Context + # Create a new context about `absolute_path` + # + # The directory will not be created if it doesn't exist. + # Call `#make!` to create it. + # + # source://spoom-1.1.12/lib/spoom/context.rb:37 + sig { params(absolute_path: ::String).void } + def initialize(absolute_path); end + + # The absolute path to the directory this context is about + # + # source://spoom-1.1.12/lib/spoom/context.rb:17 + sig { returns(::String) } + def absolute_path; end + + # Returns the absolute path to `relative_path` in the context's directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:43 + sig { params(relative_path: ::String).returns(::String) } + def absolute_path_to(relative_path); end + + # Run a command with `bundle` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:150 + sig { params(command: ::String, version: T.nilable(::String)).returns(::Spoom::ExecResult) } + def bundle(command, version: T.unsafe(nil)); end + + # Run a command `bundle exec` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:163 + sig { params(command: ::String, version: T.nilable(::String)).returns(::Spoom::ExecResult) } + def bundle_exec(command, version: T.unsafe(nil)); end + + # Run `bundle install` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:157 + sig { params(version: T.nilable(::String)).returns(::Spoom::ExecResult) } + def bundle_install!(version: T.unsafe(nil)); end + + # Delete this context and its content + # + # Warning: it will `rm -rf` the context directory on the file system. + # + # source://spoom-1.1.12/lib/spoom/context.rb:112 + sig { void } + def destroy!; end + + # Run a command in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:120 + sig { params(command: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) } + def exec(command, capture_err: T.unsafe(nil)); end + + # Does `relative_path` point to an existing file in this context directory? + # + # source://spoom-1.1.12/lib/spoom/context.rb:72 + sig { params(relative_path: ::String).returns(T::Boolean) } + def file?(relative_path); end + + # Run a command prefixed by `git` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:171 + sig { params(command: ::String).returns(::Spoom::ExecResult) } + def git(command); end + + # Run `git checkout` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:183 + sig { params(ref: ::String).returns(::Spoom::ExecResult) } + def git_checkout!(ref: T.unsafe(nil)); end + + # Get the current git branch in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:189 + sig { returns(T.nilable(::String)) } + def git_current_branch; end + + # Run `git init` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:177 + sig { params(branch: ::String).void } + def git_init!(branch: T.unsafe(nil)); end + + # List all files in this context matching `pattern` + # + # source://spoom-1.1.12/lib/spoom/context.rb:58 + sig { params(pattern: ::String).returns(T::Array[::String]) } + def glob(pattern = T.unsafe(nil)); end + + # List all files at the top level of this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:66 + sig { returns(T::Array[::String]) } + def list; end + + # Create the context directory at `absolute_path` + # + # source://spoom-1.1.12/lib/spoom/context.rb:51 + sig { void } + def mkdir!; end + + # Move the file or directory from `from_relative_path` to `to_relative_path` + # + # source://spoom-1.1.12/lib/spoom/context.rb:102 + sig { params(from_relative_path: ::String, to_relative_path: ::String).void } + def move!(from_relative_path, to_relative_path); end + + # Return the contents of the file at `relative_path` in this context directory + # + # Will raise if the file doesn't exist. + # + # source://spoom-1.1.12/lib/spoom/context.rb:80 + sig { params(relative_path: ::String).returns(::String) } + def read(relative_path); end + + # Read the strictness sigil from the file at `relative_path` (returns `nil` if no sigil) + # + # source://spoom-1.1.12/lib/spoom/context.rb:215 + sig { params(relative_path: ::String).returns(T.nilable(::String)) } + def read_file_strictness(relative_path); end + + # Read the `contents` of the Gemfile in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:138 + sig { returns(T.nilable(::String)) } + def read_gemfile; end + + # Read the contents of `sorbet/config` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:203 + sig { returns(::String) } + def read_sorbet_config; end + + # Remove the path at `relative_path` (recursive + force) in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:96 + sig { params(relative_path: ::String).void } + def remove!(relative_path); end + + # Run `bundle exec srb` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:197 + sig { params(command: ::String).returns(::Spoom::ExecResult) } + def srb(command); end + + # Write `contents` in the file at `relative_path` in this context directory + # + # Append to the file if `append` is true. + # + # source://spoom-1.1.12/lib/spoom/context.rb:88 + sig { params(relative_path: ::String, contents: ::String, append: T::Boolean).void } + def write!(relative_path, contents = T.unsafe(nil), append: T.unsafe(nil)); end + + # Set the `contents` of the Gemfile in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:144 + sig { params(contents: ::String, append: T::Boolean).void } + def write_gemfile!(contents, append: T.unsafe(nil)); end + + # Set the `contents` of `sorbet/config` in this context directory + # + # source://spoom-1.1.12/lib/spoom/context.rb:209 + sig { params(contents: ::String, append: T::Boolean).void } + def write_sorbet_config!(contents, append: T.unsafe(nil)); end + + class << self + # Create a new context in the system's temporary directory + # + # `name` is used as prefix to the temporary directory name. + # The directory will be created if it doesn't exist. + # + # source://spoom-1.1.12/lib/spoom/context.rb:27 + sig { params(name: T.nilable(::String)).returns(T.attached_class) } + def mktmp!(name = T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:5 +module Spoom::Coverage + class << self + # source://spoom-1.1.12/lib/spoom/coverage.rb:69 + sig do + params( + snapshots: T::Array[::Spoom::Coverage::Snapshot], + palette: ::Spoom::Coverage::D3::ColorPalette, + path: ::String + ).returns(::Spoom::Coverage::Report) + end + def report(snapshots, palette:, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage.rb:89 + sig { params(path: ::String).returns(::Spoom::FileTree) } + def sigils_tree(path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage.rb:16 + sig do + params( + path: ::String, + rbi: T::Boolean, + sorbet_bin: T.nilable(::String) + ).returns(::Spoom::Coverage::Snapshot) + end + def snapshot(path: T.unsafe(nil), rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage.rb:84 + sig { params(path: ::String).returns(::Spoom::Sorbet::Config) } + def sorbet_config(path: T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:88 +module Spoom::Coverage::Cards; end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:89 +class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:98 + sig { params(template: ::String, title: T.nilable(::String), body: T.nilable(::String)).void } + def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end + + # @return [String, nil] + # + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:95 + def body; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:95 + sig { returns(T.nilable(::String)) } + def title; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:92 +Spoom::Coverage::Cards::Card::TEMPLATE = T.let(T.unsafe(nil), String) + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:105 +class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card + abstract! + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:112 + sig { void } + def initialize; end + + # @abstract + # + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:120 + sig { abstract.returns(::String) } + def erb; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:115 + sig { override.returns(::String) } + def html; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:153 +class Spoom::Coverage::Cards::Map < ::Spoom::Coverage::Cards::Card + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:157 + sig { params(sigils_tree: ::Spoom::FileTree, title: ::String).void } + def initialize(sigils_tree:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:123 +class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:132 + sig { params(snapshot: ::Spoom::Coverage::Snapshot, title: ::String).void } + def initialize(snapshot:, title: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:143 + sig { returns(::Spoom::Coverage::D3::Pie::Calls) } + def pie_calls; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:138 + sig { returns(::Spoom::Coverage::D3::Pie::Sigils) } + def pie_sigils; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:148 + sig { returns(::Spoom::Coverage::D3::Pie::Sigs) } + def pie_sigs; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:129 + sig { returns(::Spoom::Coverage::Snapshot) } + def snapshot; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:126 +Spoom::Coverage::Cards::Snapshot::TEMPLATE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:225 +class Spoom::Coverage::Cards::SorbetIntro < ::Spoom::Coverage::Cards::Erb + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:229 + sig { params(sorbet_intro_commit: T.nilable(::String), sorbet_intro_date: T.nilable(::Time)).void } + def initialize(sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:235 + sig { override.returns(::String) } + def erb; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:162 +class Spoom::Coverage::Cards::Timeline < ::Spoom::Coverage::Cards::Card + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:166 + sig { params(title: ::String, timeline: ::Spoom::Coverage::D3::Timeline).void } + def initialize(title:, timeline:); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:179 +class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:183 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:197 +class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:201 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:215 +class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:219 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:170 +class Spoom::Coverage::Cards::Timeline::Sigils < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:174 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:188 +class Spoom::Coverage::Cards::Timeline::Sigs < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:192 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:206 +class Spoom::Coverage::Cards::Timeline::Versions < ::Spoom::Coverage::Cards::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:210 + sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void } + def initialize(snapshots:, title: T.unsafe(nil)); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:6 +module Spoom::Coverage::D3 + class << self + # source://spoom-1.1.12/lib/spoom/coverage/d3.rb:61 + sig { params(palette: ::Spoom::Coverage::D3::ColorPalette).returns(::String) } + def header_script(palette); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3.rb:21 + sig { returns(::String) } + def header_style; end + end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:7 +class Spoom::Coverage::D3::Base + abstract! + + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:17 + sig { params(id: ::String, data: T.untyped).void } + def initialize(id, data); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:37 + sig { returns(::String) } + def html; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:14 + sig { returns(::String) } + def id; end + + # @abstract + # + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:50 + sig { abstract.returns(::String) } + def script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:45 + sig { returns(::String) } + def tooltip; end + + class << self + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:31 + sig { returns(::String) } + def header_script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/base.rb:26 + sig { returns(::String) } + def header_style; end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:12 +Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:11 +Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:14 +Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:15 +Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:13 +Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:9 +class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:59 + sig { override.returns(::String) } + def script; end + + class << self + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:40 + sig { returns(::String) } + def header_script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:14 + sig { returns(::String) } + def header_style; end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:148 +class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:152 + sig { params(id: ::String, sigils_tree: ::Spoom::FileTree).void } + def initialize(id, sigils_tree); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:181 + sig { params(node: ::Spoom::FileTree::Node).returns(::Float) } + def tree_node_score(node); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:173 + sig { params(node: ::Spoom::FileTree::Node).returns(T.nilable(::String)) } + def tree_node_strictness(node); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/circle_map.rb:160 + sig { params(node: ::Spoom::FileTree::Node).returns(T::Hash[::Symbol, T.untyped]) } + def tree_node_to_json(node); end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3.rb:103 +class Spoom::Coverage::D3::ColorPalette < ::T::Struct + prop :false, ::String + prop :ignore, ::String + prop :strict, ::String + prop :strong, ::String + prop :true, ::String + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:9 +class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base + abstract! + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:16 + sig { params(id: ::String, title: ::String, data: T.untyped).void } + def initialize(id, title, data); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:56 + sig { override.returns(::String) } + def script; end + + class << self + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:43 + sig { returns(::String) } + def header_script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:25 + sig { returns(::String) } + def header_style; end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:141 +class Spoom::Coverage::D3::Pie::Calls < ::Spoom::Coverage::D3::Pie + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:145 + sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void } + def initialize(id, title, snapshot); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:150 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:123 +class Spoom::Coverage::D3::Pie::Sigils < ::Spoom::Coverage::D3::Pie + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:127 + sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void } + def initialize(id, title, snapshot); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:132 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:159 +class Spoom::Coverage::D3::Pie::Sigs < ::Spoom::Coverage::D3::Pie + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:163 + sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void } + def initialize(id, title, snapshot); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/pie.rb:168 + sig { override.returns(::String) } + def tooltip; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:9 +class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base + abstract! + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:16 + sig { params(id: ::String, data: T.untyped, keys: T::Array[::String]).void } + def initialize(id, data, keys); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:187 + sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) } + def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:203 + sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) } + def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end + + # @abstract + # + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:126 + sig { abstract.returns(::String) } + def plot; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:217 + sig { params(y: ::String).returns(::String) } + def points(y:); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:101 + sig { override.returns(::String) } + def script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:129 + sig { returns(::String) } + def x_scale; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:145 + sig { returns(::String) } + def x_ticks; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:158 + sig { params(min: ::String, max: ::String, ticks: ::String).returns(::String) } + def y_scale(min:, max:, ticks:); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:174 + sig { params(ticks: ::String, format: ::String, padding: ::Integer).returns(::String) } + def y_ticks(ticks:, format:, padding:); end + + class << self + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:79 + sig { returns(::String) } + def header_script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:25 + sig { returns(::String) } + def header_style; end + end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:448 +class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::Stacked + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:452 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:466 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:502 +class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:506 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:574 + sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) } + def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:614 + sig { override.returns(::String) } + def plot; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:534 + sig { override.returns(::String) } + def script; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:520 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:282 +class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:286 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:311 + sig { override.returns(::String) } + def plot; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:298 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:421 +class Spoom::Coverage::D3::Timeline::Sigils < ::Spoom::Coverage::D3::Timeline::Stacked + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:425 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:439 + sig { override.returns(::String) } + def tooltip; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:475 +class Spoom::Coverage::D3::Timeline::Sigs < ::Spoom::Coverage::D3::Timeline::Stacked + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:479 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:493 + sig { override.returns(::String) } + def tooltip; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:329 +class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline + abstract! + + # source://sorbet-runtime-0.5.10346/lib/types/private/abstract/declare.rb:37 + def initialize(*args, &blk); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:388 + sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) } + def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:377 + sig { override.returns(::String) } + def plot; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:336 + sig { override.returns(::String) } + def script; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:232 +class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:236 + sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void } + def initialize(id, snapshots); end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:263 + sig { override.returns(::String) } + def plot; end + + # source://spoom-1.1.12/lib/spoom/coverage/d3/timeline.rb:249 + sig { override.returns(::String) } + def tooltip; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:38 +class Spoom::Coverage::Page < ::Spoom::Coverage::Template + abstract! + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:53 + sig { params(title: ::String, palette: ::Spoom::Coverage::D3::ColorPalette, template: ::String).void } + def initialize(title:, palette:, template: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:75 + sig { returns(::String) } + def body_html; end + + # @abstract + # + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:80 + sig { abstract.returns(T::Array[::Spoom::Coverage::Cards::Card]) } + def cards; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:83 + sig { returns(::String) } + def footer_html; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:70 + sig { returns(::String) } + def header_html; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:65 + sig { returns(::String) } + def header_script; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:60 + sig { returns(::String) } + def header_style; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:50 + sig { returns(::Spoom::Coverage::D3::ColorPalette) } + def palette; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:47 + sig { returns(::String) } + def title; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:44 +Spoom::Coverage::Page::TEMPLATE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:246 +class Spoom::Coverage::Report < ::Spoom::Coverage::Page + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:274 + sig do + params( + project_name: ::String, + palette: ::Spoom::Coverage::D3::ColorPalette, + snapshots: T::Array[::Spoom::Coverage::Snapshot], + sigils_tree: ::Spoom::FileTree, + sorbet_intro_commit: T.nilable(::String), + sorbet_intro_date: T.nilable(::Time) + ).void + end + def initialize(project_name:, palette:, snapshots:, sigils_tree:, sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:302 + sig { override.returns(T::Array[::Spoom::Coverage::Cards::Card]) } + def cards; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:291 + sig { override.returns(::String) } + def header_html; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:250 + sig { returns(::String) } + def project_name; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:262 + sig { returns(::Spoom::FileTree) } + def sigils_tree; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:259 + sig { returns(T::Array[::Spoom::Coverage::Snapshot]) } + def snapshots; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:253 + sig { returns(T.nilable(::String)) } + def sorbet_intro_commit; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:256 + sig { returns(T.nilable(::Time)) } + def sorbet_intro_date; end +end + +# source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:6 +class Spoom::Coverage::Snapshot < ::T::Struct + prop :calls_typed, ::Integer, default: T.unsafe(nil) + prop :calls_untyped, ::Integer, default: T.unsafe(nil) + prop :classes, ::Integer, default: T.unsafe(nil) + prop :commit_sha, T.nilable(::String), default: T.unsafe(nil) + prop :commit_timestamp, T.nilable(::Integer), default: T.unsafe(nil) + prop :duration, ::Integer, default: T.unsafe(nil) + prop :files, ::Integer, default: T.unsafe(nil) + prop :methods_with_sig, ::Integer, default: T.unsafe(nil) + prop :methods_without_sig, ::Integer, default: T.unsafe(nil) + prop :modules, ::Integer, default: T.unsafe(nil) + prop :rbi_files, ::Integer, default: T.unsafe(nil) + prop :sigils, T::Hash[::String, ::Integer], default: T.unsafe(nil) + prop :singleton_classes, ::Integer, default: T.unsafe(nil) + prop :timestamp, ::Integer, default: T.unsafe(nil) + prop :version_runtime, T.nilable(::String), default: T.unsafe(nil) + prop :version_static, T.nilable(::String), default: T.unsafe(nil) + + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:30 + sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void } + def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:36 + sig { params(arg: T.untyped).returns(::String) } + def to_json(*arg); end + + class << self + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:44 + sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) } + def from_json(json); end + + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:49 + sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) } + def from_obj(obj); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# The strictness name as found in the Sorbet metrics file +# +# source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:27 +Spoom::Coverage::Snapshot::STRICTNESSES = T.let(T.unsafe(nil), Array) + +# source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:81 +class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:85 + sig { params(snapshot: ::Spoom::Coverage::Snapshot).void } + def print_snapshot(snapshot); end + + private + + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:134 + sig { params(value: T.nilable(::Integer), total: T.nilable(::Integer)).returns(::String) } + def percent(value, total); end + + # source://spoom-1.1.12/lib/spoom/coverage/snapshot.rb:123 + sig { params(hash: T::Hash[::String, ::Integer], total: ::Integer).void } + def print_map(hash, total); end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/coverage/report.rb:10 +class Spoom::Coverage::Template + abstract! + + # Create a new template from an Erb file path + # + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:18 + sig { params(template: ::String).void } + def initialize(template:); end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:23 + sig { returns(::String) } + def erb; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:33 + sig { returns(::Binding) } + def get_binding; end + + # source://spoom-1.1.12/lib/spoom/coverage/report.rb:28 + sig { returns(::String) } + def html; end +end + +# source://spoom-1.1.12/lib/spoom.rb:12 +class Spoom::Error < ::StandardError; end + +# source://spoom-1.1.12/lib/spoom.rb:14 +class Spoom::ExecResult < ::T::Struct + const :err, ::String + const :exit_code, ::Integer + const :out, ::String + const :status, T::Boolean + + # source://spoom-1.1.12/lib/spoom.rb:23 + sig { returns(::String) } + def to_s; end + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# Build a file hierarchy from a set of file paths. +# +# source://spoom-1.1.12/lib/spoom/file_tree.rb:6 +class Spoom::FileTree + # source://spoom-1.1.12/lib/spoom/file_tree.rb:13 + sig { params(paths: T::Enumerable[::String], strip_prefix: T.nilable(::String)).void } + def initialize(paths = T.unsafe(nil), strip_prefix: T.unsafe(nil)); end + + # Add a `path` to the tree + # + # This will create all nodes until the root of `path`. + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:29 + sig { params(path: ::String).returns(::Spoom::FileTree::Node) } + def add_path(path); end + + # Add all `paths` to the tree + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:21 + sig { params(paths: T::Enumerable[::String]).void } + def add_paths(paths); end + + # All the nodes in this tree + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:51 + sig { returns(T::Array[::Spoom::FileTree::Node]) } + def nodes; end + + # All the paths in this tree + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:59 + sig { returns(T::Array[::String]) } + def paths; end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:71 + sig do + params( + out: T.any(::IO, ::StringIO), + show_strictness: T::Boolean, + colors: T::Boolean, + indent_level: ::Integer + ).void + end + def print(out: T.unsafe(nil), show_strictness: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end + + # All root nodes + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:45 + sig { returns(T::Array[::Spoom::FileTree::Node]) } + def roots; end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:10 + sig { returns(T.nilable(::String)) } + def strip_prefix; end + + private + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:85 + sig do + params( + node: ::Spoom::FileTree::Node, + collected_nodes: T::Array[::Spoom::FileTree::Node] + ).returns(T::Array[::Spoom::FileTree::Node]) + end + def collect_nodes(node, collected_nodes = T.unsafe(nil)); end +end + +# A node representing either a file or a directory inside a FileTree +# +# source://spoom-1.1.12/lib/spoom/file_tree.rb:92 +class Spoom::FileTree::Node < ::T::Struct + const :children, T::Hash[::String, ::Spoom::FileTree::Node], default: T.unsafe(nil) + const :name, ::String + const :parent, T.nilable(::Spoom::FileTree::Node) + + # Full path to this node from root + # + # source://spoom-1.1.12/lib/spoom/file_tree.rb:106 + sig { returns(::String) } + def path; end + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# An internal class used to print a FileTree +# +# See `FileTree#print` +# +# source://spoom-1.1.12/lib/spoom/file_tree.rb:117 +class Spoom::FileTree::TreePrinter < ::Spoom::Printer + # source://spoom-1.1.12/lib/spoom/file_tree.rb:132 + sig do + params( + tree: ::Spoom::FileTree, + out: T.any(::IO, ::StringIO), + show_strictness: T::Boolean, + colors: T::Boolean, + indent_level: ::Integer + ).void + end + def initialize(tree:, out: T.unsafe(nil), show_strictness: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:144 + sig { params(node: ::Spoom::FileTree::Node).void } + def print_node(node); end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:171 + sig { params(nodes: T::Array[::Spoom::FileTree::Node]).void } + def print_nodes(nodes); end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:139 + sig { void } + def print_tree; end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:121 + sig { returns(::Spoom::FileTree) } + def tree; end + + private + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:178 + sig { params(node: ::Spoom::FileTree::Node).returns(T.nilable(::String)) } + def node_strictness(node); end + + # source://spoom-1.1.12/lib/spoom/file_tree.rb:186 + sig { params(strictness: T.nilable(::String)).returns(::Spoom::Color) } + def strictness_color(strictness); end +end + +# Execute git commands +# +# source://spoom-1.1.12/lib/spoom/git.rb:8 +module Spoom::Git + class << self + # Git commands + # + # source://spoom-1.1.12/lib/spoom/git.rb:36 + sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def checkout(*arg, path: T.unsafe(nil)); end + + # Get the commit Time for a `sha` + # + # source://spoom-1.1.12/lib/spoom/git.rb:81 + sig { params(sha: ::String, path: ::String).returns(T.nilable(::Time)) } + def commit_time(sha, path: T.unsafe(nil)); end + + # Get the commit epoch timestamp for a `sha` + # + # source://spoom-1.1.12/lib/spoom/git.rb:72 + sig { params(sha: ::String, path: ::String).returns(T.nilable(::Integer)) } + def commit_timestamp(sha, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/git.rb:61 + sig { params(path: ::String).returns(T.nilable(::String)) } + def current_branch(path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/git.rb:41 + sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def diff(*arg, path: T.unsafe(nil)); end + + # Translate a git epoch timestamp into a Time + # + # source://spoom-1.1.12/lib/spoom/git.rb:99 + sig { params(timestamp: ::String).returns(::Time) } + def epoch_to_time(timestamp); end + + # Execute a `command` + # + # source://spoom-1.1.12/lib/spoom/git.rb:14 + sig { params(command: ::String, arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def exec(command, *arg, path: T.unsafe(nil)); end + + # Get the last commit sha + # + # source://spoom-1.1.12/lib/spoom/git.rb:90 + sig { params(path: ::String).returns(T.nilable(::String)) } + def last_commit(path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/git.rb:46 + sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def log(*arg, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/git.rb:51 + sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def rev_parse(*arg, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/git.rb:56 + sig { params(arg: ::String, path: ::String).returns(::Spoom::ExecResult) } + def show(*arg, path: T.unsafe(nil)); end + + # Get the hash of the commit introducing the `sorbet/config` file + # + # source://spoom-1.1.12/lib/spoom/git.rb:111 + sig { params(path: ::String).returns(T.nilable(::String)) } + def sorbet_intro_commit(path: T.unsafe(nil)); end + + # Get the hash of the commit removing the `sorbet/config` file + # + # source://spoom-1.1.12/lib/spoom/git.rb:123 + sig { params(path: ::String).returns(T.nilable(::String)) } + def sorbet_removal_commit(path: T.unsafe(nil)); end + + # Is there uncommited changes in `path`? + # + # source://spoom-1.1.12/lib/spoom/git.rb:105 + sig { params(path: ::String).returns(T::Boolean) } + def workdir_clean?(path: T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:5 +module Spoom::LSP; end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:13 +class Spoom::LSP::Client + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:17 + sig { params(sorbet_bin: ::String, sorbet_args: ::String, path: ::String).void } + def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:229 + sig { void } + def close; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:131 + sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) } + def definitions(uri, line, column); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:212 + sig { params(uri: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) } + def document_symbols(uri); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:89 + sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T.nilable(::Spoom::LSP::Hover)) } + def hover(uri, line, column); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:27 + sig { returns(::Integer) } + def next_id; end + + # LSP requests + # + # @raise [Error::AlreadyOpen] + # + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:72 + sig { params(workspace_path: ::String).void } + def open(workspace_path); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:54 + sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) } + def read; end + + # @raise [Error::BadHeaders] + # + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:43 + sig { returns(T.nilable(::String)) } + def read_raw; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:173 + sig do + params( + uri: ::String, + line: ::Integer, + column: ::Integer, + include_decl: T::Boolean + ).returns(T::Array[::Spoom::LSP::Location]) + end + def references(uri, line, column, include_decl = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:37 + sig { params(message: ::Spoom::LSP::Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) } + def send(message); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:32 + sig { params(json_string: ::String).void } + def send_raw(json_string); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:110 + sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::SignatureHelp]) } + def signatures(uri, line, column); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:197 + sig { params(query: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) } + def symbols(query); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp.rb:152 + sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) } + def type_definitions(uri, line, column); end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:178 +class Spoom::LSP::Diagnostic < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :code, ::Integer + const :informations, ::Object + const :message, ::String + const :range, ::Spoom::LSP::Range + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:202 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:207 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:191 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:212 +class Spoom::LSP::DocumentSymbol < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :children, T::Array[::Spoom::LSP::DocumentSymbol] + const :detail, T.nilable(::String) + const :kind, ::Integer + const :location, T.nilable(::Spoom::LSP::Location) + const :name, ::String + const :range, T.nilable(::Spoom::LSP::Range) + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:240 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:272 + sig { returns(::String) } + def kind_string; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:267 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:227 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:276 +Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash) + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:6 +class Spoom::LSP::Error < ::StandardError; end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:7 +class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:8 +class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:10 +class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:32 + sig { params(uri: ::String, diagnostics: T::Array[::Spoom::LSP::Diagnostic]).void } + def initialize(uri, diagnostics); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:17 + sig { returns(T::Array[::Spoom::LSP::Diagnostic]) } + def diagnostics; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:14 + sig { returns(::String) } + def uri; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:23 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Error::Diagnostics) } + def from_json(json); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:19 +class Spoom::LSP::Hover < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :contents, ::String + const :range, T.nilable(T::Range[T.untyped]) + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:39 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:45 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:30 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:112 +class Spoom::LSP::Location < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :range, ::Spoom::LSP::Range + const :uri, ::String + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:132 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:138 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:123 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# A general message as defined by JSON-RPC. +# +# The language server protocol always uses `"2.0"` as the `jsonrpc` version. +# +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:12 +class Spoom::LSP::Message + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:19 + sig { void } + def initialize; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:24 + sig { returns(T::Hash[T.untyped, T.untyped]) } + def as_json; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:16 + sig { returns(::String) } + def jsonrpc; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:32 + sig { params(args: T.untyped).returns(::String) } + def to_json(*args); end +end + +# A notification message. +# +# A processed notification message must not send a response back. They work like events. +# +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:64 +class Spoom::LSP::Notification < ::Spoom::LSP::Message + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:74 + sig { params(method: ::String, params: T::Hash[T.untyped, T.untyped]).void } + def initialize(method, params); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:68 + sig { returns(::String) } + def method; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:71 + sig { returns(T::Hash[T.untyped, T.untyped]) } + def params; end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:50 +class Spoom::LSP::Position < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :char, ::Integer + const :line, ::Integer + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:70 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:75 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:61 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# @abstract Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:9 +module Spoom::LSP::PrintableSymbol + interface! + + # @abstract + # + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:16 + sig { abstract.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:80 +class Spoom::LSP::Range < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :end, ::Spoom::LSP::Position + const :start, ::Spoom::LSP::Position + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:100 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:107 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:91 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# A request message to describe a request between the client and the server. +# +# Every processed request must send a response back to the sender of the request. +# +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:40 +class Spoom::LSP::Request < ::Spoom::LSP::Message + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:53 + sig { params(id: ::Integer, method: ::String, params: T::Hash[T.untyped, T.untyped]).void } + def initialize(id, method, params); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:44 + sig { returns(::Integer) } + def id; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:47 + sig { returns(::String) } + def method; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/base.rb:50 + sig { returns(T::Hash[T.untyped, T.untyped]) } + def params; end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:40 +class Spoom::LSP::ResponseError < ::Spoom::LSP::Error + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:63 + sig { params(code: ::Integer, message: ::String, data: T::Hash[T.untyped, T.untyped]).void } + def initialize(code, message, data); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:44 + sig { returns(::Integer) } + def code; end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:47 + sig { returns(T::Hash[T.untyped, T.untyped]) } + def data; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/errors.rb:53 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::ResponseError) } + def from_json(json); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:143 +class Spoom::LSP::SignatureHelp < ::T::Struct + include ::Spoom::LSP::PrintableSymbol + + const :doc, ::Object + const :label, T.nilable(::String) + const :params, T::Array[T.untyped] + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:165 + sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void } + def accept_printer(printer); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:173 + sig { returns(::String) } + def to_s; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:155 + sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) } + def from_json(json); end + + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:306 +class Spoom::LSP::SymbolPrinter < ::Spoom::Printer + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:323 + sig do + params( + out: T.any(::IO, ::StringIO), + colors: T::Boolean, + indent_level: ::Integer, + prefix: T.nilable(::String) + ).void + end + def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil), prefix: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:345 + sig { params(uri: ::String).returns(::String) } + def clean_uri(uri); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:313 + sig { returns(T.nilable(::String)) } + def prefix; end + + # @return [String, nil] + # + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:313 + def prefix=(_arg0); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:353 + sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void } + def print_list(objects); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:333 + sig { params(object: T.nilable(::Spoom::LSP::PrintableSymbol)).void } + def print_object(object); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:340 + sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void } + def print_objects(objects); end + + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:310 + sig { returns(T::Set[::Integer]) } + def seen; end + + # @return [Set<Integer>] + # + # source://spoom-1.1.12/lib/spoom/sorbet/lsp/structures.rb:310 + def seen=(_arg0); end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://spoom-1.1.12/lib/spoom/printer.rb:7 +class Spoom::Printer + include ::Spoom::Colorize + + abstract! + + # source://spoom-1.1.12/lib/spoom/printer.rb:19 + sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void } + def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end + + # Colorize `string` with color if `@colors` + # + # source://spoom-1.1.12/lib/spoom/printer.rb:80 + sig { params(string: ::String, color: ::Spoom::Color).returns(::String) } + def colorize(string, *color); end + + # Decrease indent level + # + # source://spoom-1.1.12/lib/spoom/printer.rb:33 + sig { void } + def dedent; end + + # Increase indent level + # + # source://spoom-1.1.12/lib/spoom/printer.rb:27 + sig { void } + def indent; end + + # source://spoom-1.1.12/lib/spoom/printer.rb:16 + sig { returns(T.any(::IO, ::StringIO)) } + def out; end + + # @return [IO, StringIO] + # + # source://spoom-1.1.12/lib/spoom/printer.rb:16 + def out=(_arg0); end + + # Print `string` into `out` + # + # source://spoom-1.1.12/lib/spoom/printer.rb:39 + sig { params(string: T.nilable(::String)).void } + def print(string); end + + # Print `string` colored with `color` into `out` + # + # Does not use colors unless `@colors`. + # + # source://spoom-1.1.12/lib/spoom/printer.rb:49 + sig { params(string: T.nilable(::String), color: ::Spoom::Color).void } + def print_colored(string, *color); end + + # Print `string` with indent and newline + # + # source://spoom-1.1.12/lib/spoom/printer.rb:64 + sig { params(string: T.nilable(::String)).void } + def printl(string); end + + # Print a new line into `out` + # + # source://spoom-1.1.12/lib/spoom/printer.rb:58 + sig { void } + def printn; end + + # Print an indent space into `out` + # + # source://spoom-1.1.12/lib/spoom/printer.rb:74 + sig { void } + def printt; end +end + +# source://spoom-1.1.12/lib/spoom.rb:10 +Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/config.rb:5 +module Spoom::Sorbet + class << self + # source://spoom-1.1.12/lib/spoom/sorbet.rb:31 + sig do + params( + arg: ::String, + path: ::String, + capture_err: T::Boolean, + sorbet_bin: T.nilable(::String) + ).returns(::Spoom::ExecResult) + end + def srb(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end + + # List all files typechecked by Sorbet from its `config` + # + # source://spoom-1.1.12/lib/spoom/sorbet.rb:55 + sig { params(config: ::Spoom::Sorbet::Config, path: ::String).returns(T::Array[::String]) } + def srb_files(config, path: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet.rb:93 + sig do + params( + arg: ::String, + path: ::String, + capture_err: T::Boolean, + sorbet_bin: T.nilable(::String) + ).returns(T.nilable(T::Hash[::String, ::Integer])) + end + def srb_metrics(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet.rb:48 + sig do + params( + arg: ::String, + path: ::String, + capture_err: T::Boolean, + sorbet_bin: T.nilable(::String) + ).returns(::Spoom::ExecResult) + end + def srb_tc(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet.rb:71 + sig do + params( + arg: ::String, + path: ::String, + capture_err: T::Boolean, + sorbet_bin: T.nilable(::String) + ).returns(T.nilable(::String)) + end + def srb_version(*arg, path: T.unsafe(nil), capture_err: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end + + # Get `gem` version from the `Gemfile.lock` content + # + # Returns `nil` if `gem` cannot be found in the Gemfile. + # + # source://spoom-1.1.12/lib/spoom/sorbet.rb:116 + sig { params(gem: ::String, path: ::String).returns(T.nilable(::String)) } + def version_from_gemfile_lock(gem: T.unsafe(nil), path: T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet.rb:16 +Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet.rb:14 +Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String) + +# Parse Sorbet config files +# +# Parses a Sorbet config file: +# +# ```ruby +# config = Spoom::Sorbet::Config.parse_file("sorbet/config") +# puts config.paths # "." +# ``` +# +# Parses a Sorbet config string: +# +# ```ruby +# config = Spoom::Sorbet::Config.parse_string(<<~CONFIG) +# a +# --file=b +# --ignore=c +# CONFIG +# puts config.paths # "a", "b" +# puts config.ignore # "c" +# ``` +# +# source://spoom-1.1.12/lib/spoom/sorbet/config.rb:26 +class Spoom::Sorbet::Config + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:36 + sig { void } + def initialize; end + + # @return [Array<String>] + # + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:30 + def allowed_extensions; end + + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:44 + sig { returns(::Spoom::Sorbet::Config) } + def copy; end + + # @return [Array<String>] + # + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:30 + def ignore; end + + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:33 + sig { returns(T::Boolean) } + def no_stdlib; end + + # @return [Boolean] + # + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:33 + def no_stdlib=(_arg0); end + + # Returns self as a string of options that can be passed to Sorbet + # + # Example: + # ~~~rb + # config = Sorbet::Config.new + # config.paths << "/foo" + # config.paths << "/bar" + # config.ignore << "/baz" + # config.allowed_extensions << ".rb" + # + # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb" + # ~~~ + # + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:66 + sig { returns(::String) } + def options_string; end + + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:30 + sig { returns(T::Array[::String]) } + def paths; end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:79 + sig { params(sorbet_config_path: ::String).returns(::Spoom::Sorbet::Config) } + def parse_file(sorbet_config_path); end + + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:84 + sig { params(sorbet_config: ::String).returns(::Spoom::Sorbet::Config) } + def parse_string(sorbet_config); end + + private + + # source://spoom-1.1.12/lib/spoom/sorbet/config.rb:148 + sig { params(line: ::String).returns(::String) } + def parse_option(line); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:6 +module Spoom::Sorbet::Errors + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:13 + sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(T::Array[::Spoom::Sorbet::Errors::Error]) } + def sort_errors_by_code(errors); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:7 +Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:122 +class Spoom::Sorbet::Errors::Error + include ::Comparable + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:148 + sig do + params( + file: T.nilable(::String), + line: T.nilable(::Integer), + message: T.nilable(::String), + code: T.nilable(::Integer), + more: T::Array[::String] + ).void + end + def initialize(file, line, message, code, more = T.unsafe(nil)); end + + # By default errors are sorted by location + # + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:159 + sig { params(other: T.untyped).returns(::Integer) } + def <=>(other); end + + # @return [Integer, nil] + # + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:130 + def code; end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:127 + sig { returns(T.nilable(::String)) } + def file; end + + # Other files associated with the error + # + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:137 + sig { returns(T::Set[::String]) } + def files_from_error_sections; end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:130 + sig { returns(T.nilable(::Integer)) } + def line; end + + # @return [String, nil] + # + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:127 + def message; end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:133 + sig { returns(T::Array[::String]) } + def more; end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:166 + sig { returns(::String) } + def to_s; end +end + +# Parse errors from Sorbet output +# +# source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:18 +class Spoom::Sorbet::Errors::Parser + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:40 + sig { params(error_url_base: ::String).void } + def initialize(error_url_base: T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:47 + sig { params(output: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) } + def parse(output); end + + private + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:111 + sig { params(line: ::String).void } + def append_error(line); end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:103 + sig { void } + def close_error; end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:70 + sig { params(error_url_base: ::String).returns(::Regexp) } + def error_line_match_regexp(error_url_base); end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:87 + sig { params(line: ::String).returns(T.nilable(::Spoom::Sorbet::Errors::Error)) } + def match_error_line(line); end + + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:96 + sig { params(error: ::Spoom::Sorbet::Errors::Error).void } + def open_error(error); end + + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:33 + sig { params(output: ::String, error_url_base: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) } + def parse_string(output, error_url_base: T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/errors.rb:21 +Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array) + +# source://spoom-1.1.12/lib/spoom/sorbet.rb:15 +Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/metrics.rb:8 +module Spoom::Sorbet::MetricsParser + class << self + # source://spoom-1.1.12/lib/spoom/sorbet/metrics.rb:15 + sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) } + def parse_file(path, prefix = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/metrics.rb:25 + sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) } + def parse_hash(obj, prefix = T.unsafe(nil)); end + + # source://spoom-1.1.12/lib/spoom/sorbet/metrics.rb:20 + sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) } + def parse_string(string, prefix = T.unsafe(nil)); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/metrics.rb:9 +Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet.rb:18 +Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:9 +module Spoom::Sorbet::Sigils + class << self + # changes the sigil in the file at the passed path to the specified new strictness + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:69 + sig { params(path: T.any(::Pathname, ::String), new_strictness: ::String).returns(T::Boolean) } + def change_sigil_in_file(path, new_strictness); end + + # changes the sigil to have a new strictness in a list of files + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:80 + sig { params(path_list: T::Array[::String], new_strictness: ::String).returns(T::Array[::String]) } + def change_sigil_in_files(path_list, new_strictness); end + + # returns a string containing the strictness of a sigil in a file at the passed path + # * returns nil if no sigil + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:60 + sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) } + def file_strictness(path); end + + # finds all files in the specified directory with the passed strictness + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:94 + sig do + params( + directory: T.any(::Pathname, ::String), + strictness: ::String, + extension: ::String + ).returns(T::Array[::String]) + end + def files_with_sigil_strictness(directory, strictness, extension: T.unsafe(nil)); end + + # returns the full sigil comment string for the passed strictness + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:35 + sig { params(strictness: ::String).returns(::String) } + def sigil_string(strictness); end + + # returns the strictness of a sigil in the passed file content string (nil if no sigil) + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:47 + sig { params(content: ::String).returns(T.nilable(::String)) } + def strictness_in_content(content); end + + # returns a string which is the passed content but with the sigil updated to a new strictness + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:53 + sig { params(content: ::String, new_strictness: ::String).returns(::String) } + def update_sigil(content, new_strictness); end + + # returns true if the passed string is a valid strictness (else false) + # + # source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:41 + sig { params(strictness: ::String).returns(T::Boolean) } + def valid_strictness?(strictness); end + end +end + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:28 +Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:13 +Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:12 +Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:17 +Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:15 +Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:16 +Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:14 +Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String) + +# source://spoom-1.1.12/lib/spoom/sorbet/sigils.rb:19 +Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array) + +# source://spoom-1.1.12/lib/spoom/timeline.rb:7 +class Spoom::Timeline + # source://spoom-1.1.12/lib/spoom/timeline.rb:11 + sig { params(from: ::Time, to: ::Time, path: ::String).void } + def initialize(from, to, path: T.unsafe(nil)); end + + # Return one commit for each date in `dates` + # + # source://spoom-1.1.12/lib/spoom/timeline.rb:38 + sig { params(dates: T::Array[::Time]).returns(T::Array[::String]) } + def commits_for_dates(dates); end + + # Return all months between `from` and `to` + # + # source://spoom-1.1.12/lib/spoom/timeline.rb:25 + sig { returns(T::Array[::Time]) } + def months; end + + # Return one commit for each month between `from` and `to` + # + # source://spoom-1.1.12/lib/spoom/timeline.rb:19 + sig { returns(T::Array[::String]) } + def ticks; end +end + +# source://spoom-1.1.12/lib/spoom/version.rb:5 +Spoom::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/tapioca@0.9.4.rbi b/sorbet/rbi/gems/tapioca@0.9.4.rbi new file mode 100644 index 00000000..cfd74a1c --- /dev/null +++ b/sorbet/rbi/gems/tapioca@0.9.4.rbi @@ -0,0 +1,2883 @@ +# typed: false + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `tapioca` gem. +# Please instead update this file by running `bin/tapioca gem tapioca`. + +class Bundler::Dependency < ::Gem::Dependency + include ::Tapioca::Gemfile::AutoRequireHook +end + +# We need to do the alias-method-chain dance since Bootsnap does the same, +# and prepended modules and alias-method-chain don't play well together. +# +# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked! +# That's because RubyGems does alias-method-chain for Kernel#require and such, +# so, if Bootsnap were to do prepend, it might end up breaking RubyGems. +# +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:65 +class Module + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:78 + def append_features(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:68 + def autoload(const_name, path); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:90 + def extend_object(obj); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:66 + def prepend_features(constant); end +end + +# source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:4 +module RBI; end + +# source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:5 +class RBI::Tree < ::RBI::NodeWithComments + # source://rbi-0.0.15/lib/rbi/model.rb:115 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T::Array[::RBI::Comment], + block: T.nilable(T.proc.params(node: ::RBI::Tree).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # source://rbi-0.0.15/lib/rbi/model.rb:122 + sig { params(node: ::RBI::Node).void } + def <<(node); end + + # source://rbi-0.0.15/lib/rbi/printer.rb:224 + sig { override.params(v: ::RBI::Printer).void } + def accept_printer(v); end + + # source://rbi-0.0.15/lib/rbi/rewriters/add_sig_templates.rb:66 + sig { params(with_todo_comment: T::Boolean).void } + def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/annotate.rb:48 + sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void } + def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:38 + sig do + params( + name: ::String, + superclass_name: T.nilable(::String), + block: T.nilable(T.proc.params(scope: ::RBI::Scope).void) + ).returns(::RBI::Scope) + end + def create_class(name, superclass_name: T.unsafe(nil), &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:45 + sig { params(name: ::String, value: ::String).void } + def create_constant(name, value:); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:55 + sig { params(name: ::String).void } + def create_extend(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:50 + sig { params(name: ::String).void } + def create_include(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:88 + sig do + params( + name: ::String, + parameters: T::Array[::RBI::TypedParam], + return_type: ::String, + class_method: T::Boolean, + visibility: ::RBI::Visibility + ).void + end + def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:60 + sig { params(name: ::String).void } + def create_mixes_in_class_methods(name); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:25 + sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) } + def create_module(name, &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:9 + sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void } + def create_path(constant, &block); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:74 + sig do + params( + name: ::String, + type: ::String, + variance: ::Symbol, + fixed: T.nilable(::String), + upper: T.nilable(::String), + lower: T.nilable(::String) + ).void + end + def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/deannotate.rb:40 + sig { params(annotation: ::String).void } + def deannotate!(annotation); end + + # source://rbi-0.0.15/lib/rbi/model.rb:128 + sig { returns(T::Boolean) } + def empty?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/group_nodes.rb:38 + sig { void } + def group_nodes!; end + + # source://rbi-0.0.15/lib/rbi/index.rb:64 + sig { returns(::RBI::Index) } + def index; end + + # source://rbi-0.0.15/lib/rbi/rewriters/merge_trees.rb:318 + sig do + params( + other: ::RBI::Tree, + left_name: ::String, + right_name: ::String, + keep: ::RBI::Rewriters::Merge::Keep + ).returns(::RBI::MergeTree) + end + def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end + + # source://rbi-0.0.15/lib/rbi/rewriters/nest_non_public_methods.rb:45 + sig { void } + def nest_non_public_methods!; end + + # source://rbi-0.0.15/lib/rbi/rewriters/nest_singleton_methods.rb:35 + sig { void } + def nest_singleton_methods!; end + + # source://rbi-0.0.15/lib/rbi/model.rb:106 + sig { returns(T::Array[::RBI::Node]) } + def nodes; end + + # source://rbi-0.0.15/lib/rbi/printer.rb:231 + sig { override.returns(T::Boolean) } + def oneline?; end + + # source://rbi-0.0.15/lib/rbi/rewriters/sort_nodes.rb:105 + sig { void } + def sort_nodes!; end + + private + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:108 + sig { params(node: ::RBI::Node).returns(::RBI::Node) } + def create_node(node); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:103 + sig { returns(T::Hash[::String, ::RBI::Node]) } + def nodes_cache; end +end + +# source://tapioca-0.9.4/lib/tapioca/rbi_ext/model.rb:118 +class RBI::TypedParam < ::T::Struct + const :param, ::RBI::Param + const :type, ::String + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://rbi-0.0.15/lib/rbi/version.rb:5 +RBI::VERSION = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:5 +module T::Generic + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:13 + def [](*types); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:21 + def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:37 + def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end +end + +# This module intercepts calls to generic type instantiations and type variable definitions. +# Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used +# to look up the original call details when we are trying to do code generation. +# +# We are interested in the data of the `[]`, `type_member` and `type_template` calls which +# are all needed to generate good generic information at runtime. +# +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:12 +module T::Generic::TypeStoragePatch + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:13 + def [](*types); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:21 + def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:37 + def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &bounds_proc); end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:28 +module T::Private::Methods + class << self + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:30 + def finalize_proc(decl); end + end +end + +# source://sorbet-runtime-0.5.10346/lib/types/private/methods/_methods.rb:29 +T::Private::Methods::ARG_NOT_PROVIDED = T.let(T.unsafe(nil), Object) + +# source://sorbet-runtime-0.5.10346/lib/types/private/methods/_methods.rb:30 +T::Private::Methods::PROC_TYPE = T.let(T.unsafe(nil), Object) + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:29 +module T::Private::Methods::ProcBindPatch + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:30 + def finalize_proc(decl); end +end + +# source://sorbet-runtime-0.5.10346/lib/types/private/methods/_methods.rb:581 +T::Private::Methods::TOP_SELF = T.let(T.unsafe(nil), Object) + +class T::Types::Proc < ::T::Types::Base; end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:6 +module T::Types::ProcBindPatch + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:7 + def initialize(arg_types, returns, bind = T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/proc_bind_patch.rb:15 + def name; end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/name_patch.rb:6 +class T::Types::Simple < ::T::Types::Base + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:64 + def name; end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:59 +module T::Types::Simple::GenericPatch + # This method intercepts calls to the `name` method for simple types, so that + # it can ask the name to the type if the type is generic, since, by this point, + # we've created a clone of that type with the `name` method returning the + # appropriate name for that specific concrete type. + # + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:64 + def name; end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/name_patch.rb:7 +module T::Types::Simple::NamePatch + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/name_patch.rb:10 + def name; end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/name_patch.rb:16 + def qualified_name_of(constant); end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/name_patch.rb:8 +T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:80 +module T::Utils + class << self + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:82 + def coerce(val); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:81 +module T::Utils::CoercePatch + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:82 + def coerce(val); end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:4 +module Tapioca + class << self + # source://tapioca-0.9.4/lib/tapioca.rb:17 + sig { void } + def disable_traces; end + + # source://tapioca-0.9.4/lib/tapioca.rb:12 + sig { params(trace_name: ::Symbol, block: T.proc.params(arg0: ::TracePoint).void).void } + def register_trace(trace_name, &block); end + + # source://tapioca-0.9.4/lib/tapioca.rb:26 + sig do + type_parameters(:Result) + .params( + blk: T.proc.returns(T.type_parameter(:Result)) + ).returns(T.type_parameter(:Result)) + end + def silence_warnings(&blk); end + end +end + +# source://tapioca-0.9.4/lib/tapioca.rb:43 +Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:63 +Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:62 +Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:61 +Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/cli.rb:5 +class Tapioca::Cli < ::Thor + include ::Tapioca::CliHelper + include ::Tapioca::ConfigHelper + include ::Tapioca::EnvHelper + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:323 + def __print_version; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:306 + def annotations; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:279 + def check_shims; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:36 + def configure; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:119 + def dsl(*constants); end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:224 + def gem(*gems); end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:25 + def init; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:47 + def require; end + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:66 + def todo; end + + private + + # source://tapioca-0.9.4/lib/tapioca/cli.rb:335 + def print_init_next_steps; end + + class << self + # source://tapioca-0.9.4/lib/tapioca/cli.rb:328 + def exit_on_failure?; end + end +end + +# source://tapioca-0.9.4/lib/tapioca/cli.rb:10 +Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/helpers/cli_helper.rb:5 +module Tapioca::CliHelper + requires_ancestor { Thor::Shell } + + # source://tapioca-0.9.4/lib/tapioca/helpers/cli_helper.rb:33 + sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) } + def netrc_file(options); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/cli_helper.rb:26 + sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) } + def rbi_formatter(options); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/cli_helper.rb:12 + sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void } + def say_error(message = T.unsafe(nil), *color); end +end + +# source://tapioca-0.9.4/lib/tapioca/commands.rb:5 +module Tapioca::Commands; end + +# source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:6 +class Tapioca::Commands::Annotations < ::Tapioca::Commands::Command + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:18 + sig do + params( + central_repo_root_uris: T::Array[::String], + auth: T.nilable(::String), + netrc_file: T.nilable(::String), + central_repo_index_path: ::String, + typed_overrides: T::Hash[::String, ::String] + ).void + end + def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:36 + sig { override.void } + def execute; end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:191 + sig { params(name: ::String, content: ::String).returns(::String) } + def add_header(name, content); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:209 + sig { params(name: ::String, content: ::String).returns(::String) } + def apply_typed_override(name, content); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:132 + sig { params(repo_uris: T::Array[::String], gem_name: ::String).void } + def fetch_annotation(repo_uris, gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:109 + sig { params(gem_names: T::Array[::String]).returns(T::Array[::String]) } + def fetch_annotations(gem_names); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:150 + sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) } + def fetch_file(repo_uri, path); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:167 + sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) } + def fetch_http_file(repo_uri, path); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:98 + sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(Tapioca::RepoIndex)) } + def fetch_index(repo_uri, repo_number:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:77 + sig { returns(T::Hash[::String, Tapioca::RepoIndex]) } + def fetch_indexes; end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:159 + sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) } + def fetch_local_file(repo_uri, path); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:46 + sig { returns(T::Array[::String]) } + def list_gemfile_gems; end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:221 + sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) } + def merge_files(gem_name, contents); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:56 + sig { params(project_gems: T::Array[::String]).void } + def remove_expired_annotations(project_gems); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:248 + sig { returns(T::Hash[::String, T.nilable(::String)]) } + def repo_tokens; end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:276 + sig { params(path: ::String, repo_uri: ::String, message: ::String).void } + def say_http_error(path, repo_uri, message:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/annotations.rb:260 + sig { params(repo_uri: ::String).returns(T.nilable(::String)) } + def token_for(repo_uri); end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/check_shims.rb:6 +class Tapioca::Commands::CheckShims < ::Tapioca::Commands::Command + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIFilesHelper + + # source://tapioca-0.9.4/lib/tapioca/commands/check_shims.rb:22 + sig do + params( + gem_rbi_dir: ::String, + dsl_rbi_dir: ::String, + annotations_rbi_dir: ::String, + shim_rbi_dir: ::String, + todo_rbi_file: ::String, + payload: T::Boolean, + number_of_workers: T.nilable(::Integer) + ).void + end + def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/check_shims.rb:42 + sig { override.void } + def execute; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://tapioca-0.9.4/lib/tapioca/commands/command.rb:6 +class Tapioca::Commands::Command + include ::Thor::Base + include ::Thor::Invocation + include ::Thor::Shell + include ::Tapioca::CliHelper + extend ::Thor::Base::ClassMethods + extend ::Thor::Invocation::ClassMethods + + abstract! + + # source://tapioca-0.9.4/lib/tapioca/commands/command.rb:20 + sig { void } + def initialize; end + + # @abstract + # + # source://tapioca-0.9.4/lib/tapioca/commands/command.rb:25 + sig { abstract.void } + def execute; end + + # source://thor-1.2.1/lib/thor/base.rb:139 + sig { returns(::Thor::Actions) } + def file_writer; end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/command.rb:46 + sig do + params( + path: T.any(::Pathname, ::String), + content: ::String, + force: T::Boolean, + skip: T::Boolean, + verbose: T::Boolean + ).void + end + def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/command.rb:30 + sig { params(command: ::Symbol, args: ::String).returns(::String) } + def default_command(command, *args); end + + # source://tapioca-0.9.4/lib/tapioca/commands/command.rb:56 + sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void } + def remove_file(path, verbose: T.unsafe(nil)); end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/command.rb:10 +class Tapioca::Commands::Command::FileWriter < ::Thor + include ::Thor::Actions + extend ::Thor::Actions::ClassMethods +end + +# source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:6 +class Tapioca::Commands::Configure < ::Tapioca::Commands::Command + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:14 + sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void } + def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:30 + sig { override.void } + def execute; end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:78 + sig { void } + def create_binstub; end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:68 + sig { void } + def create_post_require; end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:40 + sig { void } + def create_sorbet_config; end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:49 + sig { void } + def create_tapioca_config; end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:91 + sig { returns(::Bundler::Installer) } + def installer; end + + # source://tapioca-0.9.4/lib/tapioca/commands/configure.rb:96 + sig { returns(::Bundler::StubSpecification) } + def spec; end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:6 +class Tapioca::Commands::Dsl < ::Tapioca::Commands::Command + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIFilesHelper + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:28 + sig do + params( + requested_constants: T::Array[::String], + outpath: ::Pathname, + only: T::Array[::String], + exclude: T::Array[::String], + file_header: T::Boolean, + compiler_path: ::String, + tapioca_path: ::String, + should_verify: T::Boolean, + quiet: T::Boolean, + verbose: T::Boolean, + number_of_workers: T.nilable(::Integer), + auto_strictness: T::Boolean, + gem_dir: ::String, + rbi_formatter: ::Tapioca::RBIFormatter + ).void + end + def initialize(requested_constants:, outpath:, only:, exclude:, file_header:, compiler_path:, tapioca_path:, should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:65 + sig { override.void } + def execute; end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:147 + sig { void } + def abort_if_pending_migrations!; end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:324 + sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) } + def build_error_for_files(cause, files); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:248 + sig do + params( + constant_name: ::String, + rbi: ::RBI::File, + outpath: ::Pathname, + quiet: T::Boolean + ).returns(T.nilable(::Pathname)) + end + def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:186 + sig { params(constant_names: T::Array[::String]).returns(T::Array[::Module]) } + def constantize(constant_names); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:209 + sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) } + def constantize_compilers(compiler_names); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:287 + sig { params(constant_name: ::String).returns(::Pathname) } + def dsl_rbi_filename(constant_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:173 + sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) } + def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:382 + sig { params(constant: ::String).returns(::String) } + def generate_command_for(constant); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:135 + sig { params(eager_load: T::Boolean).void } + def load_application(eager_load:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:158 + sig { void } + def load_dsl_compilers; end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:387 + sig { void } + def load_dsl_extensions; end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:360 + sig { returns(::Tapioca::Runtime::Loader) } + def loader; end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:266 + sig { params(dir: ::Pathname).void } + def perform_dsl_verification(dir); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:275 + sig { params(files: T::Set[::Pathname]).void } + def purge_stale_dsl_rbi_files(files); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:377 + sig { params(constant: ::String).returns(::String) } + def rbi_filename_for(constant); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:353 + sig { params(path: ::Pathname).returns(T::Array[::Pathname]) } + def rbi_files_in(path); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:333 + sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void } + def report_diff_and_exit_if_out_of_date(diff, command); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:228 + sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) } + def resolve(name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:365 + sig { params(class_name: ::String).returns(::String) } + def underscore(class_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/dsl.rb:292 + sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) } + def verify_dsl_rbi(tmp_dir:); end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:6 +class Tapioca::Commands::Gem < ::Tapioca::Commands::Command + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIFilesHelper + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:28 + sig do + params( + gem_names: T::Array[::String], + exclude: T::Array[::String], + prerequire: T.nilable(::String), + postrequire: ::String, + typed_overrides: T::Hash[::String, ::String], + outpath: ::Pathname, + file_header: T::Boolean, + include_doc: T::Boolean, + include_loc: T::Boolean, + include_exported_rbis: T::Boolean, + number_of_workers: T.nilable(::Integer), + auto_strictness: T::Boolean, + dsl_dir: ::String, + rbi_formatter: ::Tapioca::RBIFormatter + ).void + end + def initialize(gem_names:, exclude:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:68 + sig { override.void } + def execute; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:101 + sig { params(should_verify: T::Boolean, exclude: T::Array[::String]).void } + def sync(should_verify: T.unsafe(nil), exclude: T.unsafe(nil)); end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:313 + sig { returns(T::Array[::String]) } + def added_rbis; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:374 + sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) } + def build_error_for_files(cause, files); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:140 + sig { returns(::Tapioca::Gemfile) } + def bundle; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:180 + sig { params(gem: ::Tapioca::Gemfile::GemSpec).void } + def compile_gem_rbi(gem); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:308 + sig { params(gem_name: ::String).returns(::Pathname) } + def existing_rbi(gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:356 + sig { returns(T::Hash[::String, ::String]) } + def existing_rbis; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:320 + sig { params(gem_name: ::String).returns(::Pathname) } + def expected_rbi(gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:362 + sig { returns(T::Hash[::String, ::String]) } + def expected_rbis; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:292 + sig { params(file: ::String, error: ::LoadError).void } + def explain_failed_require(file, error); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:325 + sig { params(gem_name: ::String).returns(T::Boolean) } + def gem_rbi_exists?(gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:369 + sig { params(gem_name: ::String, version: ::String).returns(::Pathname) } + def gem_rbi_filename(gem_name, version); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:165 + sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) } + def gems_to_generate(gem_names); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:135 + sig { returns(::Tapioca::Runtime::Loader) } + def loader; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:379 + sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void } + def merge_with_exported_rbi(gem, file); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:350 + sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void } + def move(old_filename, new_filename); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:255 + sig { void } + def perform_additions; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:228 + sig { void } + def perform_removals; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:209 + sig { params(exclude: T::Array[::String]).void } + def perform_sync_verification(exclude: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:303 + sig { returns(T::Array[::String]) } + def removed_rbis; end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:330 + sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void } + def report_diff_and_exit_if_out_of_date(diff, command); end + + # source://tapioca-0.9.4/lib/tapioca/commands/gem.rb:145 + sig { void } + def require_gem_file; end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/require.rb:6 +class Tapioca::Commands::Require < ::Tapioca::Commands::Command + # source://tapioca-0.9.4/lib/tapioca/commands/require.rb:13 + sig { params(requires_path: ::String, sorbet_config_path: ::String).void } + def initialize(requires_path:, sorbet_config_path:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/require.rb:21 + sig { override.void } + def execute; end +end + +# source://tapioca-0.9.4/lib/tapioca/commands/todo.rb:6 +class Tapioca::Commands::Todo < ::Tapioca::Commands::Command + include ::Tapioca::SorbetHelper + + # source://tapioca-0.9.4/lib/tapioca/commands/todo.rb:15 + sig { params(todo_file: ::String, file_header: T::Boolean).void } + def initialize(todo_file:, file_header:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/todo.rb:23 + sig { override.void } + def execute; end + + private + + # source://tapioca-0.9.4/lib/tapioca/commands/todo.rb:49 + sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) } + def rbi(constants, command:); end + + # source://tapioca-0.9.4/lib/tapioca/commands/todo.rb:69 + sig { returns(T::Array[::String]) } + def unresolved_constants; end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:5 +module Tapioca::ConfigHelper + requires_ancestor { Thor } + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:18 + sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void } + def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:12 + sig { returns(::String) } + def command_name; end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:15 + sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) } + def defaults; end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:34 + sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) } + def options; end + + private + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:151 + sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) } + def build_error(msg); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:176 + sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) } + def build_error_message(config_file, errors); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:56 + sig do + params( + options: ::Thor::CoreExt::HashWithIndifferentAccess + ).returns(::Thor::CoreExt::HashWithIndifferentAccess) + end + def config_options(options); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:46 + sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void } + def filter_defaults(options); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:194 + sig do + params( + options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess) + ).returns(::Thor::CoreExt::HashWithIndifferentAccess) + end + def merge_options(*options); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:70 + sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void } + def validate_config!(config_file, config); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:102 + sig do + params( + command_options: T::Hash[::Symbol, ::Thor::Option], + config_key: ::String, + config_options: T::Hash[T.untyped, T.untyped] + ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError]) + end + def validate_config_options(command_options, config_key, config_options); end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:146 +class Tapioca::ConfigHelper::ConfigError < ::T::Struct + const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart] + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/config_helper.rb:141 +class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct + const :colors, T::Array[::Symbol] + const :message, ::String + + class << self + # source://sorbet-runtime-0.5.10346/lib/types/struct.rb:13 + def inherited(s); end + end +end + +# source://tapioca-0.9.4/lib/tapioca.rb:50 +Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:46 +Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:59 +Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:47 +Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:52 +Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash) + +# source://tapioca-0.9.4/lib/tapioca.rb:44 +Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:45 +Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/rbi_formatter.rb:29 +Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter) + +# source://tapioca-0.9.4/lib/tapioca.rb:58 +Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer) + +# source://tapioca-0.9.4/lib/tapioca.rb:48 +Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:49 +Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/dsl/compilers.rb:5 +module Tapioca::Dsl; end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:6 +class Tapioca::Dsl::Compiler + extend T::Generic + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIHelper + include ::Tapioca::Runtime::Reflection + extend ::Tapioca::Runtime::Reflection + + abstract! + + ConstantType = type_member { { upper: Module } } + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:26 + sig { params(pipeline: ::Tapioca::Dsl::Pipeline, root: ::RBI::Tree, constant: ConstantType).void } + def initialize(pipeline, root, constant); end + + # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`. + # + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:59 + sig { params(error: ::String).void } + def add_error(error); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:39 + sig { params(compiler_name: ::String).returns(T::Boolean) } + def compiler_enabled?(compiler_name); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:20 + sig { returns(ConstantType) } + def constant; end + + # @abstract + # + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:44 + sig { abstract.void } + def decorate; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:23 + sig { returns(::RBI::Tree) } + def root; end + + private + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:163 + sig { params(type: ::String).returns(::String) } + def as_nilable_type(type); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:117 + sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) } + def compile_method_parameters_to_rbi(method_def); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:153 + sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) } + def compile_method_return_type_to_rbi(method_def); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:107 + sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void } + def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end + + # Get the types of each parameter from a method signature + # + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:84 + sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) } + def parameters_types_from_signature(method_def, signature); end + + class << self + # @abstract + # + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:47 + sig { abstract.returns(T::Enumerable[::Module]) } + def gather_constants; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:34 + sig { params(constant: ::Module).returns(T::Boolean) } + def handles?(constant); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:50 + sig { returns(T::Set[::Module]) } + def processable_constants; end + + private + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:66 + sig { returns(T::Enumerable[::Class]) } + def all_classes; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/compiler.rb:72 + sig { returns(T::Enumerable[::Module]) } + def all_modules; end + end +end + +# source://tapioca-0.9.4/lib/tapioca/dsl/compilers.rb:6 +module Tapioca::Dsl::Compilers; end + +# source://tapioca-0.9.4/lib/tapioca/dsl/compilers.rb:7 +Tapioca::Dsl::Compilers::DIRECTORY = T.let(T.unsafe(nil), String) + +# DSL compilers are either built-in to Tapioca and live under the +# `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and +# can be referred to by just using the class name, or they live in +# a different namespace and can only be referred to using their fully +# qualified name. This constant encapsulates that dual lookup when +# a compiler needs to be resolved by name. +# +# source://tapioca-0.9.4/lib/tapioca/dsl/compilers.rb:18 +Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:6 +class Tapioca::Dsl::Pipeline + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:30 + sig do + params( + requested_constants: T::Array[::Module], + requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)], + excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)], + error_handler: T.proc.params(error: ::String).void, + number_of_workers: T.nilable(::Integer) + ).void + end + def initialize(requested_constants:, requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), number_of_workers: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:82 + sig { params(error: ::String).void } + def add_error(error); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:87 + sig { params(compiler_name: ::String).returns(T::Boolean) } + def compiler_enabled?(compiler_name); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:10 + sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) } + def compilers; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:16 + sig { returns(T.proc.params(error: ::String).void) } + def error_handler; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:19 + sig { returns(T::Array[::String]) } + def errors; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:13 + sig { returns(T::Array[::Module]) } + def requested_constants; end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:52 + sig do + type_parameters(:T) + .params( + blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T)) + ).returns(T::Array[T.type_parameter(:T)]) + end + def run(&blk); end + + private + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:120 + sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) } + def filter_anonymous_and_reloaded_constants(constants); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:103 + sig do + params( + requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)], + excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)] + ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) + end + def gather_compilers(requested_compilers, excluded_compilers); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:111 + sig { params(requested_constants: T::Array[::Module]).returns(T::Set[::Module]) } + def gather_constants(requested_constants); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:145 + sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) } + def rbi_for_constant(constant); end + + # source://tapioca-0.9.4/lib/tapioca/dsl/pipeline.rb:164 + sig { params(error: ::String).returns(T.noreturn) } + def report_error(error); end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/env_helper.rb:5 +module Tapioca::EnvHelper + requires_ancestor { Thor } + + # source://tapioca-0.9.4/lib/tapioca/helpers/env_helper.rb:12 + sig { params(options: T::Hash[::Symbol, T.untyped]).void } + def set_environment(options); end +end + +class Tapioca::Error < ::StandardError; end + +# source://tapioca-0.9.4/lib/tapioca/executor.rb:5 +class Tapioca::Executor + # source://tapioca-0.9.4/lib/tapioca/executor.rb:11 + sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void } + def initialize(queue, number_of_workers: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/executor.rb:28 + sig do + type_parameters(:T) + .params( + block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T)) + ).returns(T::Array[T.type_parameter(:T)]) + end + def run_in_parallel(&block); end +end + +# source://tapioca-0.9.4/lib/tapioca/executor.rb:8 +Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer) + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:5 +module Tapioca::Gem; end + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:77 +class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:84 + sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void } + def initialize(symbol, constant, node); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:81 + sig { returns(::RBI::Const) } + def node; end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:26 +class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:36 + sig { params(symbol: ::String, constant: ::BasicObject).void } + def initialize(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:33 + sig { returns(::BasicObject) } + def constant; end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:30 + sig { returns(::String) } + def symbol; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:6 +class Tapioca::Gem::Event + abstract! + + # source://sorbet-runtime-0.5.10346/lib/types/private/abstract/declare.rb:37 + def initialize(*args, &blk); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:43 +class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:52 + sig { params(symbol: ::String, constant: ::Module).void } + def initialize(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:47 + sig { override.returns(::Module) } + def constant; end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:103 +class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:6 +module Tapioca::Gem::Listeners; end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:7 +class Tapioca::Gem::Listeners::Base + abstract! + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:14 + sig { params(pipeline: ::Tapioca::Gem::Pipeline).void } + def initialize(pipeline); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:19 + sig { params(event: ::Tapioca::Gem::NodeAdded).void } + def dispatch(event); end + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:49 + sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:37 + sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void } + def on_const(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:45 + sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void } + def on_method(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/base.rb:41 + sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/dynamic_mixins.rb:7 +class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/dynamic_mixins.rb:31 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/dynamic_mixins.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/foreign_constants.rb:7 +class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/foreign_constants.rb:59 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/foreign_constants.rb:54 + sig { params(location: ::String).returns(T::Boolean) } + def mixed_in_by_gem?(location); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/foreign_constants.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:7 +class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIHelper + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:34 + sig { params(tree: ::RBI::Tree, module_name: ::String, mod: ::Module, for_visibility: T::Array[::Symbol]).void } + def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:63 + sig do + params( + tree: ::RBI::Tree, + symbol_name: ::String, + constant: ::Module, + method: T.nilable(::UnboundMethod), + visibility: ::RBI::Visibility + ).void + end + def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:191 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:184 + sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) } + def initialize_method_for(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:165 + sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) } + def method_names_by_visibility(mod); end + + # Check whether the method is defined by the constant. + # + # In most cases, it works to check that the constant is the method owner. However, + # in the case that a method is also defined in a module prepended to the constant, it + # will be owned by the prepended module, not the constant. + # + # This method implements a better way of checking whether a constant defines a method. + # It walks up the ancestor tree via the `super_method` method; if any of the super + # methods are owned by the constant, it means that the constant declares the method. + # + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:151 + sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) } + def method_owned_by_constant?(method, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:16 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/methods.rb:174 + sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) } + def struct_method?(constant, method_name); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:7 +class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:42 + sig do + params( + tree: ::RBI::Tree, + constant: ::Module, + mods: T::Array[::Module], + mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type + ).void + end + def add_mixins(tree, constant, mods, mixin_type); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:88 + sig { params(mixin_name: ::String).returns(T::Boolean) } + def filtered_mixin?(mixin_name); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:95 + sig { params(constant: ::Module).returns(T::Array[::Module]) } + def interesting_ancestors_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:75 + sig do + params( + constant: ::Module, + mixin: ::Module, + mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type + ).returns(T::Boolean) + end + def mixed_in_by_gem?(constant, mixin, mixin_type); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/mixins.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb:7 +class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb:20 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_enums.rb:7 +class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_enums.rb:25 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_enums.rb:13 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_helpers.rb:7 +class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_helpers.rb:28 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_helpers.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_props.rb:7 +class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_props.rb:32 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_props.rb:13 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb:7 +class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb:23 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb:13 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:7 +class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIHelper + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:26 + sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) } + def compile_signature(signature, parameters); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:78 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:18 + sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void } + def on_method(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:68 + sig { params(signature: T.untyped).returns(T::Boolean) } + def signature_final?(signature); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_signatures.rb:13 +Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp) + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_type_variables.rb:7 +class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_type_variables.rb:27 + sig { params(tree: ::RBI::Tree, constant: ::Module).void } + def compile_type_variable_declarations(tree, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_type_variables.rb:50 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/sorbet_type_variables.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/source_location.rb:7 +class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/source_location.rb:41 + sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void } + def add_source_location_comment(node, file, line); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/source_location.rb:13 + sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void } + def on_const(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/source_location.rb:35 + sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void } + def on_method(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/source_location.rb:19 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/subconstants.rb:7 +class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base + include ::Tapioca::Runtime::Reflection + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/subconstants.rb:36 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/subconstants.rb:15 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:7 +class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:24 + sig { params(pipeline: ::Tapioca::Gem::Pipeline).void } + def initialize(pipeline); end + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:51 + sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) } + def documentation_comments(name, sigs: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:95 + sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) } + def ignore?(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:32 + sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void } + def on_const(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:42 + sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void } + def on_method(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:37 + sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void } + def on_scope(event); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:10 +Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/gem/listeners/yard_doc.rb:21 +Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:105 +class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:130 + sig do + params( + symbol: ::String, + constant: ::Module, + method: ::UnboundMethod, + node: ::RBI::Method, + signature: T.untyped, + parameters: T::Array[[::Symbol, ::String]] + ).void + end + def initialize(symbol, constant, method, node, signature, parameters); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:109 + sig { returns(::UnboundMethod) } + def method; end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:112 + sig { returns(::RBI::Method) } + def node; end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:118 + sig { returns(T::Array[[::Symbol, ::String]]) } + def parameters; end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:115 + sig { returns(T.untyped) } + def signature; end +end + +# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below. +# +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:57 +class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event + abstract! + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:70 + sig { params(symbol: ::String, constant: ::Module).void } + def initialize(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:67 + sig { returns(::Module) } + def constant; end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:64 + sig { returns(::String) } + def symbol; end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:6 +class Tapioca::Gem::Pipeline + include ::Tapioca::Runtime::Reflection + include ::Tapioca::SorbetHelper + include ::Tapioca::RBIHelper + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:17 + sig { params(gem: ::Tapioca::Gemfile::GemSpec, include_doc: T::Boolean, include_loc: T::Boolean).void } + def initialize(gem, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:48 + sig { returns(::RBI::Tree) } + def compile; end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:14 + sig { returns(::Tapioca::Gemfile::GemSpec) } + def gem; end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:110 + sig { params(method: ::UnboundMethod).returns(T::Boolean) } + def method_in_gem?(method); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:118 + sig { params(constant: ::Module).returns(T.nilable(::String)) } + def name_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:69 + sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void } + def push_const(symbol, constant, node); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:59 + sig { params(symbol: ::String, constant: ::BasicObject).void } + def push_constant(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:64 + sig { params(symbol: ::String, constant: ::Module).void } + def push_foreign_constant(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:83 + sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void } + def push_foreign_scope(symbol, constant, node); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:97 + sig do + params( + symbol: ::String, + constant: ::Module, + method: ::UnboundMethod, + node: ::RBI::Method, + signature: T.untyped, + parameters: T::Array[[::Symbol, ::String]] + ).void + end + def push_method(symbol, constant, method, node, signature, parameters); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:76 + sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void } + def push_scope(symbol, constant, node); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:54 + sig { params(symbol: ::String).void } + def push_symbol(symbol); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:102 + sig { params(symbol_name: ::String).returns(T::Boolean) } + def symbol_in_payload?(symbol_name); end + + private + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:364 + sig { params(name: ::String).void } + def add_to_alias_namespace(name); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:369 + sig { params(name: ::String).returns(T::Boolean) } + def alias_namespaced?(name); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:213 + sig { params(name: ::String, constant: ::Module).void } + def compile_alias(name, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:199 + sig { params(symbol: ::String, constant: ::BasicObject).void } + def compile_constant(symbol, constant); end + + # Compile + # + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:194 + sig { params(symbol: ::String, constant: ::Module).void } + def compile_foreign_constant(symbol, constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:269 + sig { params(name: ::String, constant: ::Module, foreign_constant: T::Boolean).void } + def compile_module(name, constant, foreign_constant: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:234 + sig { params(name: ::String, value: ::BasicObject).void } + def compile_object(name, value); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:294 + sig { params(constant: ::Class).returns(T.nilable(::String)) } + def compile_superclass(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:343 + sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) } + def defined_in_gem?(constant, strict: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:146 + sig { params(event: ::Tapioca::Gem::Event).void } + def dispatch(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:386 + sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) } + def generic_name_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:355 + sig { params(constant: ::Module).returns(T::Array[::String]) } + def get_file_candidates(constant); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:133 + sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) } + def load_bootstrap_symbols(gem); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:376 + sig { params(name: ::String).void } + def mark_seen(name); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:399 + sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) } + def name_of_proxy_target(constant, class_name); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:141 + sig { returns(::Tapioca::Gem::Event) } + def next_event; end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:169 + sig { params(event: ::Tapioca::Gem::ConstantFound).void } + def on_constant(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:187 + sig { params(event: ::Tapioca::Gem::NodeAdded).void } + def on_node(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:160 + sig { params(event: ::Tapioca::Gem::SymbolFound).void } + def on_symbol(event); end + + # source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:381 + sig { params(name: ::String).returns(T::Boolean) } + def seen?(name); end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/pipeline.rb:11 +Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:90 +class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:97 + sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void } + def initialize(symbol, constant, node); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:94 + sig { returns(::RBI::Scope) } + def node; end +end + +# source://tapioca-0.9.4/lib/tapioca/gem/events.rb:13 +class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:20 + sig { params(symbol: ::String).void } + def initialize(symbol); end + + # source://tapioca-0.9.4/lib/tapioca/gem/events.rb:17 + sig { returns(::String) } + def symbol; end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/gem_helper.rb:5 +module Tapioca::GemHelper + # source://tapioca-0.9.4/lib/tapioca/helpers/gem_helper.rb:9 + sig { params(gemfile_dir: ::String, full_gem_path: ::String).returns(T::Boolean) } + def gem_in_app_dir?(gemfile_dir, full_gem_path); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/gem_helper.rb:15 + sig { params(full_gem_path: ::String).returns(T::Boolean) } + def gem_in_bundle_path?(full_gem_path); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/gem_helper.rb:20 + sig { params(path: T.any(::Pathname, ::String)).returns(::String) } + def to_realpath(path); end +end + +# source://tapioca-0.9.4/lib/tapioca/gemfile.rb:5 +class Tapioca::Gemfile + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:69 + sig { params(exclude: T::Array[::String]).void } + def initialize(exclude); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:60 + sig { returns(::Bundler::Definition) } + def definition; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:63 + sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) } + def dependencies; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:80 + sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) } + def gem(gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:66 + sig { returns(T::Array[::String]) } + def missing_specs; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:85 + sig { void } + def require_bundle; end + + private + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:131 + sig { returns(::String) } + def dir; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:92 + sig { returns(::File) } + def gemfile; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:126 + sig { returns(T::Array[::Symbol]) } + def groups; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:95 + sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) } + def load_dependencies; end + + # @return [File] + # + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:92 + def lockfile; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:106 + sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) } + def materialize_deps; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:121 + sig { returns(::Bundler::Runtime) } + def runtime; end +end + +# This is a module that gets prepended to `Bundler::Dependency` and +# makes sure even gems marked as `require: false` are required during +# `Bundler.require`. +# +# source://tapioca-0.9.4/lib/tapioca/gemfile.rb:18 +module Tapioca::Gemfile::AutoRequireHook + requires_ancestor { Bundler::Dependency } + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:39 + sig { returns(T.untyped) } + def autorequire; end + + class << self + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:30 + sig { params(exclude: T::Array[::String]).returns(T::Array[::String]) } + def exclude=(exclude); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:33 + sig { params(name: T.untyped).returns(T::Boolean) } + def excluded?(name); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/gemfile.rb:135 +class Tapioca::Gemfile::GemSpec + include ::Tapioca::GemHelper + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:154 + sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void } + def initialize(spec); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:179 + sig { params(path: ::String).returns(T::Boolean) } + def contains_path?(path); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:198 + sig { returns(T::Boolean) } + def export_rbi_files?; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:193 + sig { returns(T::Array[::String]) } + def exported_rbi_files; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:203 + sig { returns(::RBI::MergeTree) } + def exported_rbi_tree; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:151 + sig { returns(T::Array[::Pathname]) } + def files; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:148 + sig { returns(::String) } + def full_gem_path; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:164 + sig { params(gemfile_dir: ::String).returns(T::Boolean) } + def ignore?(gemfile_dir); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:169 + sig { returns(::String) } + def name; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:188 + sig { void } + def parse_yard_docs; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:174 + sig { returns(::String) } + def rbi_file_name; end + + # @return [String] + # + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:148 + def version; end + + private + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:217 + sig { returns(T::Array[::Pathname]) } + def collect_files; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:232 + sig { returns(T.nilable(T::Boolean)) } + def default_gem?; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:290 + sig { returns(T::Boolean) } + def gem_ignored?; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:269 + sig { params(path: ::String).returns(T::Boolean) } + def has_parent_gemspec?(path); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:237 + sig { returns(::Regexp) } + def require_paths_prefix_matcher; end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:248 + sig { params(file: ::String).returns(::Pathname) } + def resolve_to_ruby_lib_dir(file); end + + # source://tapioca-0.9.4/lib/tapioca/gemfile.rb:262 + sig { returns(::String) } + def version_string; end +end + +# source://tapioca-0.9.4/lib/tapioca/gemfile.rb:139 +Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/gemfile.rb:8 +Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) } + +# source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:5 +module Tapioca::RBIFilesHelper + requires_ancestor { Tapioca::SorbetHelper } + requires_ancestor { Thor::Shell } + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:48 + sig do + params( + index: ::RBI::Index, + shim_rbi_dir: ::String, + todo_rbi_file: ::String + ).returns(T::Hash[::String, T::Array[::RBI::Node]]) + end + def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:13 + sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void } + def index_rbi(index, kind, file); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:25 + sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void } + def index_rbis(index, kind, dir, number_of_workers:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:65 + sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) } + def location_to_payload_url(loc, path_prefix:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:86 + sig do + params( + command: ::String, + gem_dir: ::String, + dsl_dir: ::String, + auto_strictness: T::Boolean, + gems: T::Array[::Tapioca::Gemfile::GemSpec], + compilers: T::Enumerable[::Class] + ).void + end + def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end + + private + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:208 + sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[::RBI::Scope]) } + def extract_empty_scopes(nodes); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:213 + sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) } + def extract_methods_and_attrs(nodes); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:220 + sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Mixin, ::RBI::RequiresAncestor)]) } + def extract_mixins(nodes); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:227 + sig do + params( + nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)] + ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) + end + def extract_nodes_with_sigs(nodes); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:201 + sig do + params( + nodes: T::Array[::RBI::Node], + shim_rbi_dir: ::String, + todo_rbi_file: ::String + ).returns(T::Array[::RBI::Node]) + end + def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:259 + sig { params(path: ::String).returns(::String) } + def gem_name_from_rbi_path(path); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:155 + sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void } + def parse_and_index_files(index, files, number_of_workers:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:170 + sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) } + def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_files_helper.rb:232 + sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void } + def update_gem_rbis_strictnesses(errors, gem_dir); end +end + +# source://tapioca-0.9.4/lib/tapioca/rbi_formatter.rb:5 +class Tapioca::RBIFormatter < ::RBI::Formatter + # source://tapioca-0.9.4/lib/tapioca/rbi_formatter.rb:22 + sig { params(file: ::RBI::File).void } + def write_empty_body_comment!(file); end + + # source://tapioca-0.9.4/lib/tapioca/rbi_formatter.rb:15 + sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void } + def write_header!(file, command, reason: T.unsafe(nil)); end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:5 +module Tapioca::RBIHelper + include ::Tapioca::SorbetHelper + extend ::Tapioca::SorbetHelper + extend ::Tapioca::RBIHelper + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:42 + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } + def create_block_param(name, type:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:32 + sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) } + def create_kw_opt_param(name, type:, default:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:27 + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } + def create_kw_param(name, type:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:37 + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } + def create_kw_rest_param(name, type:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:17 + sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) } + def create_opt_param(name, type:, default:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:12 + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } + def create_param(name, type:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:22 + sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) } + def create_rest_param(name, type:); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:47 + sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) } + def create_typed_param(param, type); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:52 + sig { params(sig_string: ::String).returns(::String) } + def sanitize_signature_types(sig_string); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:95 + sig { params(name: ::String).returns(T::Boolean) } + def valid_method_name?(name); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:109 + sig { params(name: ::String).returns(T::Boolean) } + def valid_parameter_name?(name); end + + class << self + # source://tapioca-0.9.4/lib/tapioca/helpers/rbi_helper.rb:69 + sig do + params( + type: ::String, + variance: ::Symbol, + fixed: T.nilable(::String), + upper: T.nilable(::String), + lower: T.nilable(::String) + ).returns(::String) + end + def serialize_type_variable(type, variance, fixed, upper, lower); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/repo_index.rb:5 +class Tapioca::RepoIndex + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:22 + sig { void } + def initialize; end + + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:27 + sig { params(gem_name: ::String).void } + def <<(gem_name); end + + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:32 + sig { returns(T::Enumerable[::String]) } + def gems; end + + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:37 + sig { params(gem_name: ::String).returns(T::Boolean) } + def has_gem?(gem_name); end + + class << self + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:15 + sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(Tapioca::RepoIndex) } + def from_hash(hash); end + + # source://tapioca-0.9.4/lib/tapioca/repo_index.rb:10 + sig { params(json: ::String).returns(Tapioca::RepoIndex) } + def from_json(json); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:5 +module Tapioca::Runtime; end + +# source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:6 +class Tapioca::Runtime::DynamicMixinCompiler + include ::Tapioca::Runtime::Reflection + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:20 + sig { params(constant: ::Module).void } + def initialize(constant); end + + # @return [Array<Symbol>] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:14 + def class_attribute_predicates; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:14 + sig { returns(T::Array[::Symbol]) } + def class_attribute_readers; end + + # @return [Array<Symbol>] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:14 + def class_attribute_writers; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:137 + sig { params(tree: ::RBI::Tree).void } + def compile_class_attributes(tree); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:180 + sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) } + def compile_mixes_in_class_methods(tree); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:11 + sig { returns(T::Array[::Module]) } + def dynamic_extends; end + + # @return [Array<Module>] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:11 + def dynamic_includes; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:132 + sig { returns(T::Boolean) } + def empty_attributes?; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:222 + sig { params(qualified_mixin_name: ::String).returns(T::Boolean) } + def filtered_mixin?(qualified_mixin_name); end + + # @return [Array<Symbol>] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:17 + def instance_attribute_predicates; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:17 + sig { returns(T::Array[::Symbol]) } + def instance_attribute_readers; end + + # @return [Array<Symbol>] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:17 + def instance_attribute_writers; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/dynamic_mixin_compiler.rb:215 + sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) } + def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end +end + +# This class is responsible for storing and looking up information related to generic types. +# +# The class stores 2 different kinds of data, in two separate lookup tables: +# 1. a lookup of generic type instances by name: `@generic_instances` +# 2. a lookup of type variable serializer by constant and type variable +# instance: `@type_variables` +# +# By storing the above data, we can cheaply query each constant against this registry +# to see if it declares any generic type variables. This becomes a simple lookup in the +# `@type_variables` hash table with the given constant. +# +# If there is no entry, then we can cheaply know that we can skip generic type +# information generation for this type. +# +# On the other hand, if we get a result, then the result will be a hash of type +# variable to type variable serializers. This allows us to associate type variables +# to the constant names that represent them, easily. +# +# source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:23 +module Tapioca::Runtime::GenericTypeRegistry + class << self + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:64 + sig { params(instance: ::Object).returns(T::Boolean) } + def generic_type_instance?(instance); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:69 + sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) } + def lookup_type_variables(constant); end + + # This method is responsible for building the name of the instantiated concrete type + # and cloning the given constant so that we can return a type that is the same + # as the current type but is a different instance and has a different name method. + # + # We cache those cloned instances by their name in `@generic_instances`, so that + # we don't keep instantiating a new type every single time it is referenced. + # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only + # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and + # 2 hash lookups (for the other two `Foo[Integer]`s). + # + # This method returns the created or cached clone of the constant. + # + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:49 + sig { params(constant: T.untyped, types: T.untyped).returns(::Module) } + def register_type(constant, types); end + + # This method is called from intercepted calls to `type_member` and `type_template`. + # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable` + # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`. + # + # This method creates a `String` with that data and stores it in the + # `@type_variables` lookup table, keyed by the `constant` and `type_variable`. + # + # Finally, the original `type_variable` is returned from this method, so that the caller + # can return it from the original methods as well. + # + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:88 + sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void } + def register_type_variable(constant, type_variable); end + + private + + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:97 + sig { params(constant: ::Module, name: ::String).returns(::Module) } + def create_generic_type(constant, name); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:135 + sig { params(constant: ::Class).returns(::Class) } + def create_safe_subclass(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/generic_type_registry.rb:162 + sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) } + def lookup_or_initialize_type_variables(constant); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:6 +class Tapioca::Runtime::Loader + include ::Tapioca::GemHelper + include ::Thor::Base + include ::Thor::Invocation + include ::Thor::Shell + extend ::Thor::Base::ClassMethods + extend ::Thor::Invocation::ClassMethods + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:14 + sig do + params( + gemfile: ::Tapioca::Gemfile, + initialize_file: T.nilable(::String), + require_file: T.nilable(::String) + ).void + end + def load_bundle(gemfile, initialize_file, require_file); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:27 + sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void } + def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil)); end + + private + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:88 + sig { void } + def eager_load_rails_app; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:114 + sig { void } + def load_rails_engines; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:59 + sig { returns(T::Array[T.untyped]) } + def rails_engines; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:49 + sig { params(file: T.nilable(::String)).void } + def require_helper(file); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:73 + sig { params(path: ::String).void } + def safe_require(path); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/loader.rb:80 + sig { void } + def silence_deprecations; end +end + +module Tapioca::Runtime::Reflection + extend ::Tapioca::Runtime::Reflection + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:60 + sig { params(constant: ::Module).returns(T::Array[::Module]) } + def ancestors_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:75 + sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) } + def are_equal?(object, other); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:172 + sig { params(singleton_class: ::Module).returns(T.nilable(::Module)) } + def attached_class_of(singleton_class); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:39 + sig { params(object: ::BasicObject).returns(::Class) } + def class_of(object); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:32 + sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) } + def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:44 + sig { params(constant: ::Module).returns(T::Array[::Symbol]) } + def constants_of(constant); end + + # Returns an array with all classes that are < than the supplied class. + # + # class C; end + # descendants_of(C) # => [] + # + # class B < C; end + # descendants_of(C) # => [B] + # + # class A < B; end + # descendants_of(C) # => [B, A] + # + # class D < C; end + # descendants_of(C) # => [B, A, D] + # + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:150 + sig do + type_parameters(:U) + .params( + klass: T.all(::Class, T.type_parameter(:U)) + ).returns(T::Array[T.type_parameter(:U)]) + end + def descendants_of(klass); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:95 + sig { params(constant: ::Module).returns(T::Array[::Module]) } + def inherited_ancestors_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:128 + sig { params(constant: ::Module, method: ::Symbol).returns(::Method) } + def method_of(constant, method); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:49 + sig { params(constant: ::Module).returns(T.nilable(::String)) } + def name_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:123 + sig { params(type: ::T::Types::Base).returns(::String) } + def name_of_type(type); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:70 + sig { params(object: ::BasicObject).returns(::Integer) } + def object_id_of(object); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:90 + sig { params(constant: ::Module).returns(T::Array[::Symbol]) } + def private_instance_methods_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:85 + sig { params(constant: ::Module).returns(T::Array[::Symbol]) } + def protected_instance_methods_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:80 + sig { params(constant: ::Module).returns(T::Array[::Symbol]) } + def public_instance_methods_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:104 + sig { params(constant: ::Module).returns(T.nilable(::String)) } + def qualified_name_of(constant); end + + # Examines the call stack to identify the closest location where a "require" is performed + # by searching for the label "<top (required)>". If none is found, it returns the location + # labeled "<main>", which is the original call site. + # + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:162 + sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) } + def resolve_loc(locations); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:116 + sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) } + def signature_of(method); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:55 + sig { params(constant: ::Module).returns(::Class) } + def singleton_class_of(constant); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:65 + sig { params(constant: ::Class).returns(T.nilable(::Class)) } + def superclass_of(constant); end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:14 +Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:10 +Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:11 +Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:17 +Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:21 +Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:12 +Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:16 +Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:20 +Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:19 +Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:18 +Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:23 +Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:13 +Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/reflection.rb:15 +Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod) + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:6 +module Tapioca::Runtime::Trackers; end + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:7 +module Tapioca::Runtime::Trackers::Autoload + class << self + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:18 + sig { void } + def eager_load_all!; end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:30 + sig { params(constant_name: ::String).void } + def register(constant_name); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:39 + sig do + type_parameters(:Result) + .params( + block: T.proc.returns(T.type_parameter(:Result)) + ).returns(T.type_parameter(:Result)) + end + def with_disabled_exits(&block); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/autoload.rb:10 +Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc) + +# Registers a TracePoint immediately upon load to track points at which +# classes and modules are opened for definition. This is used to track +# correspondence between classes/modules and files, as this information isn't +# available in the ruby runtime without extra accounting. +module Tapioca::Runtime::Trackers::ConstantDefinition + extend ::Tapioca::Runtime::Reflection + + class << self + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/constant_definition.rb:52 + def build_constant_location(tp, locations); end + + # Returns the files in which this class or module was opened. Doesn't know + # about situations where the class was opened prior to +require+ing, + # or where metaprogramming was used via +eval+, etc. + # + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/constant_definition.rb:62 + def files_for(klass); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/constant_definition.rb:66 + def locations_for(klass); end + end +end + +module Tapioca::Runtime::Trackers::Mixin + class << self + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:52 + sig do + params( + mixin: ::Module + ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]]) + end + def constants_with_mixin(mixin); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:42 + sig { params(constant: ::Module, mixin: ::Module, mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type).void } + def register(constant, mixin, mixin_type); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/mixin.rb:27 + sig do + type_parameters(:Result) + .params( + block: T.proc.returns(T.type_parameter(:Result)) + ).returns(T.type_parameter(:Result)) + end + def with_disabled_registration(&block); end + end +end + +class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum + enums do + Prepend = new + Include = new + Extend = new + end +end + +# source://tapioca-0.9.4/lib/tapioca/runtime/trackers/required_ancestor.rb:7 +module Tapioca::Runtime::Trackers::RequiredAncestor + class << self + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/required_ancestor.rb:13 + sig { params(requiring: ::T::Helpers, block: T.proc.returns(::Module)).void } + def register(requiring, block); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/required_ancestor.rb:19 + sig { params(mod: ::Module).returns(T::Array[T.proc.returns(::Module)]) } + def required_ancestors_blocks_by(mod); end + + # source://tapioca-0.9.4/lib/tapioca/runtime/trackers/required_ancestor.rb:24 + sig { params(mod: ::Module).returns(T::Array[T.nilable(::Module)]) } + def required_ancestors_by(mod); end + end +end + +# source://tapioca-0.9.4/lib/tapioca.rb:39 +Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:38 +Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:5 +module Tapioca::SorbetHelper + # source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:29 + sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) } + def sorbet(*sorbet_args); end + + # source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:34 + sig { returns(::String) } + def sorbet_path; end + + # source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:41 + sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) } + def sorbet_supports?(feature, version: T.unsafe(nil)); end +end + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:22 +Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash) + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:13 +Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname) + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:18 +Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:8 +Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification) + +# source://tapioca-0.9.4/lib/tapioca/helpers/sorbet_helper.rb:20 +Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:5 +module Tapioca::Static; end + +# source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:6 +class Tapioca::Static::RequiresCompiler + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:10 + sig { params(sorbet_path: ::String).void } + def initialize(sorbet_path); end + + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:15 + sig { returns(::String) } + def compile; end + + private + + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:29 + sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) } + def collect_files(config); end + + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:44 + sig { params(file_path: ::String).returns(T::Enumerable[::String]) } + def collect_requires(file_path); end + + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:52 + sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) } + def file_ignored_by_sorbet?(config, file_path); end + + # source://tapioca-0.9.4/lib/tapioca/static/requires_compiler.rb:81 + sig { params(path: ::Pathname).returns(T::Array[::String]) } + def path_parts(path); end +end + +# source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:6 +module Tapioca::Static::SymbolLoader + extend ::Tapioca::SorbetHelper + extend ::Tapioca::Runtime::Reflection + + class << self + # source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:23 + sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) } + def engine_symbols(gem); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:40 + sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) } + def gem_symbols(gem); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:13 + sig { returns(T::Set[::String]) } + def payload_symbols; end + + private + + # @return [Array<T.class_of(Rails::Engine)>] + # + # source://sorbet-runtime-0.5.10346/lib/types/private/methods/_methods.rb:250 + def engines(*args, &blk); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:59 + sig { params(input: ::String, table_type: ::String).returns(::String) } + def symbol_table_json_from(input, table_type: T.unsafe(nil)); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_loader.rb:64 + sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) } + def symbols_from_paths(paths); end + end +end + +# source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:6 +class Tapioca::Static::SymbolTableParser + # source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:24 + sig { void } + def initialize; end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:57 + sig { params(name: ::String).returns(::String) } + def fully_qualified_name(name); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:30 + sig { params(object: T::Hash[::String, T.untyped]).void } + def parse_object(object); end + + # source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:21 + sig { returns(T::Set[::String]) } + def symbols; end + + class << self + # source://tapioca-0.9.4/lib/tapioca/static/symbol_table_parser.rb:10 + sig { params(json_string: ::String).returns(T::Set[::String]) } + def parse_json(json_string); end + end +end + +# source://tapioca-0.9.4/lib/tapioca.rb:41 +Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca.rb:40 +Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String) + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:98 +class Tapioca::TypeVariable < ::T::Types::TypeVariable + # @return [TypeVariable] a new instance of TypeVariable + # + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:99 + def initialize(name, variance); end + + # Returns the value of attribute name. + # + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:104 + def name; end +end + +# This is subclassing from `Module` so that instances of this type will be modules. +# The reason why we want that is because that means those instances will automatically +# get bound to the constant names they are assigned to by Ruby. As a result, we don't +# need to do any matching of constants to type variables to bind their names, Ruby will +# do that automatically for us and we get the `name` method for free from `Module`. +# +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:112 +class Tapioca::TypeVariableModule < ::Module + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:134 + sig do + params( + context: ::Module, + type: ::Tapioca::TypeVariableModule::Type, + variance: ::Symbol, + fixed: T.untyped, + lower: T.untyped, + upper: T.untyped, + bounds_proc: T.nilable(T.proc.returns(T::Hash[::Symbol, T.untyped])) + ).void + end + def initialize(context, type, variance, fixed, lower, upper, bounds_proc); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:184 + sig { returns(::Tapioca::TypeVariable) } + def coerce_to_type_variable; end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:149 + sig { returns(T.nilable(::String)) } + def name; end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:168 + sig { returns(::String) } + def serialize; end + + private + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:194 + sig do + params( + fixed: T.untyped, + lower: T.untyped, + upper: T.untyped + ).returns(T.proc.returns(T::Hash[::Symbol, T.untyped])) + end + def build_bounds_proc(fixed, lower, upper); end + + # source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:208 + sig do + type_parameters(:Result) + .params( + block: T.proc.returns(T.type_parameter(:Result)) + ).returns(T.type_parameter(:Result)) + end + def with_bound_name_pre_3_0(&block); end +end + +# source://tapioca-0.9.4/lib/tapioca/sorbet_ext/generic_name_patch.rb:115 +class Tapioca::TypeVariableModule::Type < ::T::Enum + enums do + Member = new + Template = new + end +end + +# source://tapioca-0.9.4/lib/tapioca/version.rb:5 +Tapioca::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/thor.rbi b/sorbet/rbi/gems/thor.rbi deleted file mode 100644 index 3b35a829..00000000 --- a/sorbet/rbi/gems/thor.rbi +++ /dev/null @@ -1,541 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: true -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/thor/all/thor.rbi -# -# thor-1.2.1 - -class Thor - def help(command = nil, subcommand = nil); end - def self.banner(command, namespace = nil, subcommand = nil); end - def self.baseclass; end - def self.check_unknown_options!(options = nil); end - def self.check_unknown_options?(config); end - def self.command_help(shell, command_name); end - def self.create_command(meth); end - def self.create_task(meth); end - def self.default_command(meth = nil); end - def self.default_task(meth = nil); end - def self.deprecation_warning(message); end - def self.desc(usage, description, options = nil); end - def self.disable_required_check!(*command_names); end - def self.disable_required_check; end - def self.disable_required_check?(command); end - def self.dispatch(meth, given_args, given_opts, config); end - def self.dynamic_command_class; end - def self.find_command_possibilities(meth); end - def self.find_task_possibilities(meth); end - def self.help(shell, subcommand = nil); end - def self.initialize_added; end - def self.long_desc(long_description, options = nil); end - def self.map(mappings = nil, **kw); end - def self.method_option(name, options = nil); end - def self.method_options(options = nil); end - def self.normalize_command_name(meth); end - def self.normalize_task_name(meth); end - def self.option(name, options = nil); end - def self.options(options = nil); end - def self.package_name(name, _ = nil); end - def self.printable_commands(all = nil, subcommand = nil); end - def self.printable_tasks(all = nil, subcommand = nil); end - def self.register(klass, subcommand_name, usage, description, options = nil); end - def self.retrieve_command_name(args); end - def self.retrieve_task_name(args); end - def self.stop_on_unknown_option!(*command_names); end - def self.stop_on_unknown_option; end - def self.stop_on_unknown_option?(command); end - def self.subcommand(subcommand, subcommand_class); end - def self.subcommand_classes; end - def self.subcommand_help(cmd); end - def self.subcommands; end - def self.subtask(subcommand, subcommand_class); end - def self.subtask_help(cmd); end - def self.subtasks; end - def self.task_help(shell, command_name); end - extend Thor::Base::ClassMethods - extend Thor::Invocation::ClassMethods - include Thor::Base - include Thor::Invocation - include Thor::Shell -end -class Anonymous_Struct_5 < Struct - def ancestor_name; end - def ancestor_name=(_); end - def description; end - def description=(_); end - def long_description; end - def long_description=(_); end - def name; end - def name=(_); end - def options; end - def options=(_); end - def self.[](*arg0); end - def self.inspect; end - def self.members; end - def self.new(*arg0); end - def usage; end - def usage=(_); end -end -class Thor::Command < Anonymous_Struct_5 - def formatted_usage(klass, namespace = nil, subcommand = nil); end - def handle_argument_error?(instance, error, caller); end - def handle_no_method_error?(instance, error, caller); end - def hidden?; end - def initialize(name, description, long_description, usage, options = nil); end - def initialize_copy(other); end - def local_method?(instance, name); end - def not_debugging?(instance); end - def private_method?(instance); end - def public_method?(instance); end - def required_arguments_for(klass, usage); end - def required_options; end - def run(instance, args = nil); end - def sans_backtrace(backtrace, caller); end -end -class Thor::HiddenCommand < Thor::Command - def hidden?; end -end -class Thor::DynamicCommand < Thor::Command - def initialize(name, options = nil); end - def run(instance, args = nil); end -end -module Thor::CoreExt -end -class Thor::CoreExt::HashWithIndifferentAccess < Hash - def [](key); end - def []=(key, value); end - def convert_key(key); end - def delete(key); end - def except(*keys); end - def fetch(key, *args); end - def initialize(hash = nil); end - def key?(key); end - def merge!(other); end - def merge(other); end - def method_missing(method, *args); end - def replace(other_hash); end - def reverse_merge!(other_hash); end - def reverse_merge(other); end - def to_hash; end - def values_at(*indices); end -end -class Thor::NoKwargSpellChecker < DidYouMean::SpellChecker - def initialize(dictionary); end -end -class Thor::Error < StandardError -end -class Thor::UndefinedCommandError < Thor::Error - def all_commands; end - def command; end - def initialize(command, all_commands, namespace); end -end -class Thor::UndefinedCommandError::SpellChecker - def corrections; end - def error; end - def initialize(error); end - def spell_checker; end -end -class Thor::AmbiguousCommandError < Thor::Error -end -class Thor::InvocationError < Thor::Error -end -class Thor::UnknownArgumentError < Thor::Error - def initialize(switches, unknown); end - def switches; end - def unknown; end -end -class Thor::UnknownArgumentError::SpellChecker - def corrections; end - def error; end - def initialize(error); end - def spell_checker; end -end -class Thor::RequiredArgumentMissingError < Thor::InvocationError -end -class Thor::MalformattedArgumentError < Thor::InvocationError -end -module Thor::Invocation - def _parse_initialization_options(args, opts, config); end - def _retrieve_class_and_command(name, sent_command = nil); end - def _retrieve_class_and_task(name, sent_command = nil); end - def _shared_configuration; end - def current_command_chain; end - def initialize(args = nil, options = nil, config = nil, &block); end - def invoke(name = nil, *args); end - def invoke_all; end - def invoke_command(command, *args); end - def invoke_task(command, *args); end - def invoke_with_padding(*args); end - def self.included(base); end -end -module Thor::Invocation::ClassMethods - def prepare_for_invocation(key, name); end -end -class Thor::NestedContext - def enter; end - def entered?; end - def initialize; end - def pop; end - def push; end -end -class Thor::Argument - def banner; end - def default; end - def default_banner; end - def description; end - def enum; end - def human_name; end - def initialize(name, options = nil); end - def name; end - def required; end - def required?; end - def show_default?; end - def type; end - def usage; end - def valid_type?(type); end - def validate!; end -end -class Thor::Arguments - def check_requirement!; end - def current_is_value?; end - def initialize(arguments = nil); end - def last?; end - def no_or_skip?(arg); end - def parse(args); end - def parse_array(name); end - def parse_hash(name); end - def parse_numeric(name); end - def parse_string(name); end - def peek; end - def remaining; end - def self.parse(*args); end - def self.split(args); end - def shift; end - def unshift(arg); end -end -class Thor::Option < Thor::Argument - def aliases; end - def array?; end - def boolean?; end - def dasherize(str); end - def dasherized?; end - def group; end - def hash?; end - def hide; end - def human_name; end - def initialize(name, options = nil); end - def lazy_default; end - def numeric?; end - def repeatable; end - def self.parse(key, value); end - def string?; end - def switch_name; end - def undasherize(str); end - def usage(padding = nil); end - def validate!; end - def validate_default_type!; end -end -class Thor::Options < Thor::Arguments - def assign_result!(option, result); end - def check_unknown!; end - def current_is_switch?; end - def current_is_switch_formatted?; end - def current_is_value?; end - def initialize(hash_options = nil, defaults = nil, stop_on_unknown = nil, disable_required_check = nil); end - def normalize_switch(arg); end - def parse(args); end - def parse_boolean(switch); end - def parse_peek(switch, option); end - def parsing_options?; end - def peek; end - def remaining; end - def self.to_switches(options); end - def shift; end - def switch?(arg); end - def switch_option(arg); end - def unshift(arg, is_value: nil); end -end -module Thor::Base - def args; end - def args=(arg0); end - def initialize(args = nil, local_options = nil, config = nil); end - def options; end - def options=(arg0); end - def parent_options; end - def parent_options=(arg0); end - def self.included(base); end - def self.register_klass_file(klass); end - def self.shell; end - def self.shell=(arg0); end - def self.subclass_files; end - def self.subclasses; end -end -module Thor::Shell - def _shared_configuration; end - def ask(*args, &block); end - def error(*args, &block); end - def file_collision(*args, &block); end - def initialize(args = nil, options = nil, config = nil); end - def no?(*args, &block); end - def print_in_columns(*args, &block); end - def print_table(*args, &block); end - def print_wrapped(*args, &block); end - def say(*args, &block); end - def say_error(*args, &block); end - def say_status(*args, &block); end - def set_color(*args, &block); end - def shell; end - def shell=(arg0); end - def terminal_width(*args, &block); end - def with_padding; end - def yes?(*args, &block); end -end -module Thor::LineEditor - def self.best_available; end - def self.readline(prompt, options = nil); end -end -class Thor::LineEditor::Basic - def echo?; end - def get_input; end - def initialize(prompt, options); end - def options; end - def prompt; end - def readline; end - def self.available?; end -end -class Thor::LineEditor::Readline < Thor::LineEditor::Basic - def add_to_history?; end - def completion_options; end - def completion_proc; end - def readline; end - def self.available?; end - def use_path_completion?; end -end -class Thor::LineEditor::Readline::PathCompletion - def absolute_matches; end - def base_path; end - def glob_pattern; end - def initialize(text); end - def matches; end - def relative_matches; end - def text; end -end -module Thor::Sandbox -end -module Thor::Util - def self.camel_case(str); end - def self.escape_globs(path); end - def self.escape_html(string); end - def self.find_by_namespace(namespace); end - def self.find_class_and_command_by_namespace(namespace, fallback = nil); end - def self.find_class_and_task_by_namespace(namespace, fallback = nil); end - def self.globs_for(path); end - def self.load_thorfile(path, content = nil, debug = nil); end - def self.namespace_from_thor_class(constant); end - def self.namespaces_in_content(contents, file = nil); end - def self.ruby_command; end - def self.snake_case(str); end - def self.thor_classes_in(klass); end - def self.thor_root; end - def self.thor_root_glob; end - def self.user_home; end -end -module Thor::Base::ClassMethods - def all_commands; end - def all_tasks; end - def allow_incompatible_default_type!; end - def argument(name, options = nil); end - def arguments; end - def attr_accessor(*arg0); end - def attr_reader(*arg0); end - def attr_writer(*arg0); end - def baseclass; end - def basename; end - def build_option(name, options, scope); end - def build_options(options, scope); end - def check_default_type!; end - def check_default_type; end - def check_unknown_options!; end - def check_unknown_options; end - def check_unknown_options?(config); end - def class_option(name, options = nil); end - def class_options(options = nil); end - def class_options_help(shell, groups = nil); end - def commands; end - def create_command(meth); end - def create_task(meth); end - def disable_required_check?(command_name); end - def dispatch(command, given_args, given_opts, config); end - def exit_on_failure?; end - def find_and_refresh_command(name); end - def find_and_refresh_task(name); end - def from_superclass(method, default = nil); end - def group(name = nil); end - def handle_argument_error(command, error, args, arity); end - def handle_no_command_error(command, has_namespace = nil); end - def handle_no_task_error(command, has_namespace = nil); end - def inherited(klass); end - def initialize_added; end - def is_thor_reserved_word?(word, type); end - def method_added(meth); end - def namespace(name = nil); end - def no_commands(&block); end - def no_commands?; end - def no_commands_context; end - def no_tasks(&block); end - def print_options(shell, options, group_name = nil); end - def public_command(*names); end - def public_task(*names); end - def remove_argument(*names); end - def remove_class_option(*names); end - def remove_command(*names); end - def remove_task(*names); end - def start(given_args = nil, config = nil); end - def stop_on_unknown_option?(command_name); end - def strict_args_position!; end - def strict_args_position; end - def strict_args_position?(config); end - def tasks; end -end -module Thor::Actions - def _cleanup_options_and_set(options, key); end - def _shared_configuration; end - def action(instance); end - def add_file(destination, *args, &block); end - def add_link(destination, *args); end - def append_file(path, *args, &block); end - def append_to_file(path, *args, &block); end - def apply(path, config = nil); end - def behavior; end - def behavior=(arg0); end - def capture(*args); end - def chmod(path, mode, config = nil); end - def comment_lines(path, flag, *args); end - def concat(string); end - def copy_file(source, *args, &block); end - def create_file(destination, *args, &block); end - def create_link(destination, *args); end - def destination_root; end - def destination_root=(root); end - def directory(source, *args, &block); end - def empty_directory(destination, config = nil); end - def find_in_source_paths(file); end - def get(source, *args, &block); end - def gsub_file(path, flag, *args, &block); end - def in_root; end - def initialize(args = nil, options = nil, config = nil); end - def inject_into_class(path, klass, *args, &block); end - def inject_into_file(destination, *args, &block); end - def inject_into_module(path, module_name, *args, &block); end - def insert_into_file(destination, *args, &block); end - def inside(dir = nil, config = nil, &block); end - def link_file(source, *args); end - def output_buffer; end - def output_buffer=(arg0); end - def prepend_file(path, *args, &block); end - def prepend_to_file(path, *args, &block); end - def relative_to_original_destination_root(path, remove_dot = nil); end - def remove_dir(path, config = nil); end - def remove_file(path, config = nil); end - def run(command, config = nil); end - def run_ruby_script(command, config = nil); end - def self.included(base); end - def source_paths; end - def template(source, *args, &block); end - def thor(command, *args); end - def uncomment_lines(path, flag, *args); end - def with_output_buffer(buf = nil); end -end -class Thor::Actions::EmptyDirectory - def base; end - def config; end - def convert_encoded_instructions(filename); end - def destination; end - def destination=(destination); end - def exists?; end - def given_destination; end - def initialize(base, destination, config = nil); end - def invoke!; end - def invoke_with_conflict_check(&block); end - def on_conflict_behavior; end - def on_file_clash_behavior; end - def pretend?; end - def relative_destination; end - def revoke!; end - def say_status(status, color); end -end -class Thor::Actions::CreateFile < Thor::Actions::EmptyDirectory - def data; end - def force_on_collision?; end - def force_or_skip_or_conflict(force, skip, &block); end - def identical?; end - def initialize(base, destination, data, config = nil); end - def invoke!; end - def on_conflict_behavior(&block); end - def render; end -end -class Thor::Actions::CreateLink < Thor::Actions::CreateFile - def data; end - def exists?; end - def identical?; end - def invoke!; end -end -class Thor::Actions::Directory < Thor::Actions::EmptyDirectory - def execute!; end - def file_level_lookup(previous_lookup); end - def files(lookup); end - def initialize(base, source, destination = nil, config = nil, &block); end - def invoke!; end - def revoke!; end - def source; end -end -class Thor::Actions::CapturableERB < ERB - def set_eoutvar(compiler, eoutvar = nil); end -end -class Thor::Actions::InjectIntoFile < Thor::Actions::EmptyDirectory - def behavior; end - def flag; end - def initialize(base, destination, data, config); end - def invoke!; end - def replace!(regexp, string, force); end - def replacement; end - def revoke!; end - def say_status(behavior, warning: nil, color: nil); end -end -module Thor::Actions::ClassMethods - def add_runtime_options!; end - def source_paths; end - def source_paths_for_search; end - def source_root(path = nil); end -end -class Thor::Group - def _invoke_for_class_method(klass, command = nil, *args, &block); end - def self.banner; end - def self.baseclass; end - def self.class_options_help(shell, groups = nil); end - def self.create_command(meth); end - def self.create_task(meth); end - def self.desc(description = nil); end - def self.dispatch(command, given_args, given_opts, config); end - def self.get_options_from_invocations(group_options, base_options); end - def self.handle_argument_error(command, error, _args, arity); end - def self.help(shell); end - def self.invocation_blocks; end - def self.invocations; end - def self.invoke(*names, &block); end - def self.invoke_from_option(*names, &block); end - def self.printable_commands(*arg0); end - def self.printable_tasks(*arg0); end - def self.remove_invocation(*names); end - def self.self_command; end - def self.self_task; end - extend Thor::Base::ClassMethods - extend Thor::Invocation::ClassMethods - include Thor::Base - include Thor::Invocation - include Thor::Shell -end diff --git a/sorbet/rbi/gems/thor@1.2.1.rbi b/sorbet/rbi/gems/thor@1.2.1.rbi new file mode 100644 index 00000000..a4f6669a --- /dev/null +++ b/sorbet/rbi/gems/thor@1.2.1.rbi @@ -0,0 +1,3956 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `thor` gem. +# Please instead update this file by running `bin/tapioca gem thor`. + +# source://thor-1.2.1/lib/thor/command.rb:1 +class Thor + include ::Thor::Base + include ::Thor::Invocation + include ::Thor::Shell + extend ::Thor::Base::ClassMethods + extend ::Thor::Invocation::ClassMethods + + # source://thor-1.2.1/lib/thor.rb:505 + def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + class << self + # Extend check unknown options to accept a hash of conditions. + # + # === Parameters + # options<Hash>: A hash containing :only and/or :except keys + # + # source://thor-1.2.1/lib/thor.rb:255 + def check_unknown_options!(options = T.unsafe(nil)); end + + # Overwrite check_unknown_options? to take subcommands and options into account. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor.rb:268 + def check_unknown_options?(config); end + + # Prints help information for the given command. + # + # ==== Parameters + # shell<Thor::Shell> + # command_name<String> + # + # source://thor-1.2.1/lib/thor.rb:172 + def command_help(shell, command_name); end + + # Sets the default command when thor is executed without an explicit command to be called. + # + # ==== Parameters + # meth<Symbol>:: name of the default command + # + # source://thor-1.2.1/lib/thor.rb:21 + def default_command(meth = T.unsafe(nil)); end + + # Sets the default command when thor is executed without an explicit command to be called. + # + # ==== Parameters + # meth<Symbol>:: name of the default command + # + # source://thor-1.2.1/lib/thor.rb:21 + def default_task(meth = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/base.rb:26 + def deprecation_warning(message); end + + # Defines the usage and the description of the next command. + # + # ==== Parameters + # usage<String> + # description<String> + # options<String> + # + # source://thor-1.2.1/lib/thor.rb:54 + def desc(usage, description, options = T.unsafe(nil)); end + + # Disable the check for required options for the given commands. + # This is useful if you have a command that does not need the required options + # to work, like help. + # + # ==== Parameters + # Symbol ...:: A list of commands that should be affected. + # + # source://thor-1.2.1/lib/thor.rb:339 + def disable_required_check!(*command_names); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor.rb:343 + def disable_required_check?(command); end + + # Prints help information for this class. + # + # ==== Parameters + # shell<Thor::Shell> + # + # source://thor-1.2.1/lib/thor.rb:195 + def help(shell, subcommand = T.unsafe(nil)); end + + # Defines the long description of the next command. + # + # ==== Parameters + # long description<String> + # + # source://thor-1.2.1/lib/thor.rb:71 + def long_desc(long_description, options = T.unsafe(nil)); end + + # Maps an input to a command. If you define: + # + # map "-T" => "list" + # + # Running: + # + # thor -T + # + # Will invoke the list command. + # + # ==== Parameters + # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command. + # + # source://thor-1.2.1/lib/thor.rb:93 + def map(mappings = T.unsafe(nil), **kw); end + + # Adds an option to the set of method options. If :for is given as option, + # it allows you to change the options from a previous defined command. + # + # def previous_command + # # magic + # end + # + # method_option :foo => :bar, :for => :previous_command + # + # def next_command + # # magic + # end + # + # ==== Parameters + # name<Symbol>:: The name of the argument. + # options<Hash>:: Described below. + # + # ==== Options + # :desc - Description for the argument. + # :required - If the argument is required or not. + # :default - Default value for this argument. It cannot be required and have default values. + # :aliases - Aliases for this option. + # :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean. + # :banner - String to show on usage notes. + # :hide - If you want to hide this option from the help. + # + # source://thor-1.2.1/lib/thor.rb:155 + def method_option(name, options = T.unsafe(nil)); end + + # Declares the options for the next command to be declared. + # + # ==== Parameters + # Hash[Symbol => Object]:: The hash key is the name of the option and the value + # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric + # or :required (string). If you give a value, the type of the value is used. + # + # source://thor-1.2.1/lib/thor.rb:121 + def method_options(options = T.unsafe(nil)); end + + # Adds an option to the set of method options. If :for is given as option, + # it allows you to change the options from a previous defined command. + # + # def previous_command + # # magic + # end + # + # method_option :foo => :bar, :for => :previous_command + # + # def next_command + # # magic + # end + # + # ==== Parameters + # name<Symbol>:: The name of the argument. + # options<Hash>:: Described below. + # + # ==== Options + # :desc - Description for the argument. + # :required - If the argument is required or not. + # :default - Default value for this argument. It cannot be required and have default values. + # :aliases - Aliases for this option. + # :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean. + # :banner - String to show on usage notes. + # :hide - If you want to hide this option from the help. + # + # source://thor-1.2.1/lib/thor.rb:155 + def option(name, options = T.unsafe(nil)); end + + # Declares the options for the next command to be declared. + # + # ==== Parameters + # Hash[Symbol => Object]:: The hash key is the name of the option and the value + # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric + # or :required (string). If you give a value, the type of the value is used. + # + # source://thor-1.2.1/lib/thor.rb:121 + def options(options = T.unsafe(nil)); end + + # Allows for custom "Command" package naming. + # + # === Parameters + # name<String> + # options<Hash> + # + # source://thor-1.2.1/lib/thor.rb:12 + def package_name(name, _ = T.unsafe(nil)); end + + # Returns commands ready to be printed. + # + # source://thor-1.2.1/lib/thor.rb:214 + def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # Returns commands ready to be printed. + # + # source://thor-1.2.1/lib/thor.rb:214 + def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # Registers another Thor subclass as a command. + # + # ==== Parameters + # klass<Class>:: Thor subclass to register + # command<String>:: Subcommand name to use + # usage<String>:: Short usage for the subcommand + # description<String>:: Description for the subcommand + # + # source://thor-1.2.1/lib/thor.rb:37 + def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end + + # Stop parsing of options as soon as an unknown option or a regular + # argument is encountered. All remaining arguments are passed to the command. + # This is useful if you have a command that can receive arbitrary additional + # options, and where those additional options should not be handled by + # Thor. + # + # ==== Example + # + # To better understand how this is useful, let's consider a command that calls + # an external command. A user may want to pass arbitrary options and + # arguments to that command. The command itself also accepts some options, + # which should be handled by Thor. + # + # class_option "verbose", :type => :boolean + # stop_on_unknown_option! :exec + # check_unknown_options! :except => :exec + # + # desc "exec", "Run a shell command" + # def exec(*args) + # puts "diagnostic output" if options[:verbose] + # Kernel.exec(*args) + # end + # + # Here +exec+ can be called with +--verbose+ to get diagnostic output, + # e.g.: + # + # $ thor exec --verbose echo foo + # diagnostic output + # foo + # + # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead: + # + # $ thor exec echo --verbose foo + # --verbose foo + # + # ==== Parameters + # Symbol ...:: A list of commands that should be affected. + # + # source://thor-1.2.1/lib/thor.rb:325 + def stop_on_unknown_option!(*command_names); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor.rb:329 + def stop_on_unknown_option?(command); end + + # source://thor-1.2.1/lib/thor.rb:234 + def subcommand(subcommand, subcommand_class); end + + # source://thor-1.2.1/lib/thor.rb:230 + def subcommand_classes; end + + # source://thor-1.2.1/lib/thor.rb:225 + def subcommands; end + + # source://thor-1.2.1/lib/thor.rb:234 + def subtask(subcommand, subcommand_class); end + + # source://thor-1.2.1/lib/thor.rb:225 + def subtasks; end + + # Prints help information for the given command. + # + # ==== Parameters + # shell<Thor::Shell> + # command_name<String> + # + # source://thor-1.2.1/lib/thor.rb:172 + def task_help(shell, command_name); end + + protected + + # The banner for this class. You can customize it if you are invoking the + # thor class by another ways which is not the Thor::Runner. It receives + # the command that is going to be invoked and a boolean which indicates if + # the namespace should be displayed as arguments. + # + # source://thor-1.2.1/lib/thor.rb:400 + def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor.rb:406 + def baseclass; end + + # source://thor-1.2.1/lib/thor.rb:414 + def create_command(meth); end + + # source://thor-1.2.1/lib/thor.rb:414 + def create_task(meth); end + + # help command has the required check disabled by default. + # + # source://thor-1.2.1/lib/thor.rb:354 + def disable_required_check; end + + # The method responsible for dispatching given the args. + # + # @yield [instance] + # + # source://thor-1.2.1/lib/thor.rb:359 + def dispatch(meth, given_args, given_opts, config); end + + # source://thor-1.2.1/lib/thor.rb:410 + def dynamic_command_class; end + + # this is the logic that takes the command name passed in by the user + # and determines whether it is an unambiguous substrings of a command or + # alias name. + # + # source://thor-1.2.1/lib/thor.rb:476 + def find_command_possibilities(meth); end + + # this is the logic that takes the command name passed in by the user + # and determines whether it is an unambiguous substrings of a command or + # alias name. + # + # source://thor-1.2.1/lib/thor.rb:476 + def find_task_possibilities(meth); end + + # source://thor-1.2.1/lib/thor.rb:436 + def initialize_added; end + + # receives a (possibly nil) command name and returns a name that is in + # the commands hash. In addition to normalizing aliases, this logic + # will determine if a shortened command is an unambiguous substring of + # a command or alias. + # + # +normalize_command_name+ also converts names like +animal-prison+ + # into +animal_prison+. + # + # @raise [AmbiguousTaskError] + # + # source://thor-1.2.1/lib/thor.rb:455 + def normalize_command_name(meth); end + + # receives a (possibly nil) command name and returns a name that is in + # the commands hash. In addition to normalizing aliases, this logic + # will determine if a shortened command is an unambiguous substring of + # a command or alias. + # + # +normalize_command_name+ also converts names like +animal-prison+ + # into +animal_prison+. + # + # @raise [AmbiguousTaskError] + # + # source://thor-1.2.1/lib/thor.rb:455 + def normalize_task_name(meth); end + + # Retrieve the command name from given args. + # + # source://thor-1.2.1/lib/thor.rb:442 + def retrieve_command_name(args); end + + # Retrieve the command name from given args. + # + # source://thor-1.2.1/lib/thor.rb:442 + def retrieve_task_name(args); end + + # source://thor-1.2.1/lib/thor.rb:349 + def stop_on_unknown_option; end + + # source://thor-1.2.1/lib/thor.rb:491 + def subcommand_help(cmd); end + + # source://thor-1.2.1/lib/thor.rb:491 + def subtask_help(cmd); end + end +end + +# source://thor-1.2.1/lib/thor/actions/empty_directory.rb:2 +module Thor::Actions + mixes_in_class_methods ::Thor::Actions::ClassMethods + + # Extends initializer to add more configuration options. + # + # ==== Configuration + # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke. + # It also accepts :force, :skip and :pretend to set the behavior + # and the respective option. + # + # destination_root<String>:: The root directory needed for some actions. + # + # source://thor-1.2.1/lib/thor/actions.rb:72 + def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end + + # Wraps an action object and call it accordingly to the thor class behavior. + # + # source://thor-1.2.1/lib/thor/actions.rb:89 + def action(instance); end + + # Create a new file relative to the destination root with the given data, + # which is the return value of a block or a data string. + # + # ==== Parameters + # destination<String>:: the relative path to the destination root. + # data<String|NilClass>:: the data to append to the file. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # create_file "lib/fun_party.rb" do + # hostname = ask("What is the virtual hostname I should use?") + # "vhost.name = #{hostname}" + # end + # + # create_file "config/apache.conf", "your apache config" + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:22 + def add_file(destination, *args, &block); end + + # Create a new file relative to the destination root from the given source. + # + # ==== Parameters + # destination<String>:: the relative path to the destination root. + # source<String|NilClass>:: the relative path to the source root. + # config<Hash>:: give :verbose => false to not log the status. + # :: give :symbolic => false for hard link. + # + # ==== Examples + # + # create_link "config/apache.conf", "/etc/apache.conf" + # + # source://thor-1.2.1/lib/thor/actions/create_link.rb:17 + def add_link(destination, *args); end + + # Append text to a file. Since it depends on insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # data<String>:: the data to append to the file, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # append_to_file 'config/environments/test.rb', 'config.gem "rspec"' + # + # append_to_file 'config/environments/test.rb' do + # 'config.gem "rspec"' + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:195 + def append_file(path, *args, &block); end + + # Append text to a file. Since it depends on insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # data<String>:: the data to append to the file, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # append_to_file 'config/environments/test.rb', 'config.gem "rspec"' + # + # append_to_file 'config/environments/test.rb' do + # 'config.gem "rspec"' + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:195 + def append_to_file(path, *args, &block); end + + # Loads an external file and execute it in the instance binding. + # + # ==== Parameters + # path<String>:: The path to the file to execute. Can be a web address or + # a relative path from the source root. + # + # ==== Examples + # + # apply "http://gist.github.com/103208" + # + # apply "recipes/jquery.rb" + # + # source://thor-1.2.1/lib/thor/actions.rb:216 + def apply(path, config = T.unsafe(nil)); end + + # Returns the value of attribute behavior. + # + # source://thor-1.2.1/lib/thor/actions.rb:10 + def behavior; end + + # Sets the attribute behavior + # + # @param value the value to set the attribute behavior to. + # + # source://thor-1.2.1/lib/thor/actions.rb:10 + def behavior=(_arg0); end + + # Changes the mode of the given file or directory. + # + # ==== Parameters + # mode<Integer>:: the file mode + # path<String>:: the name of the file to change mode + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # chmod "script/server", 0755 + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:148 + def chmod(path, mode, config = T.unsafe(nil)); end + + # Comment all lines matching a given regex. It will leave the space + # which existed before the beginning of the line in tact and will insert + # a single space after the comment hash. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # flag<Regexp|String>:: the regexp or string used to decide which lines to comment + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # comment_lines 'config/initializers/session_store.rb', /cookie_store/ + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:312 + def comment_lines(path, flag, *args); end + + # ==== Examples + # + # copy_file "README", "doc/README" + # + # copy_file "doc/README" + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:21 + def copy_file(source, *args, &block); end + + # Create a new file relative to the destination root with the given data, + # which is the return value of a block or a data string. + # + # ==== Parameters + # destination<String>:: the relative path to the destination root. + # data<String|NilClass>:: the data to append to the file. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # create_file "lib/fun_party.rb" do + # hostname = ask("What is the virtual hostname I should use?") + # "vhost.name = #{hostname}" + # end + # + # create_file "config/apache.conf", "your apache config" + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:22 + def create_file(destination, *args, &block); end + + # Create a new file relative to the destination root from the given source. + # + # ==== Parameters + # destination<String>:: the relative path to the destination root. + # source<String|NilClass>:: the relative path to the source root. + # config<Hash>:: give :verbose => false to not log the status. + # :: give :symbolic => false for hard link. + # + # ==== Examples + # + # create_link "config/apache.conf", "/etc/apache.conf" + # + # source://thor-1.2.1/lib/thor/actions/create_link.rb:17 + def create_link(destination, *args); end + + # Returns the root for this thor class (also aliased as destination root). + # + # source://thor-1.2.1/lib/thor/actions.rb:99 + def destination_root; end + + # Sets the root for this thor class. Relatives path are added to the + # directory where the script was invoked and expanded. + # + # source://thor-1.2.1/lib/thor/actions.rb:106 + def destination_root=(root); end + + # Copies recursively the files from source directory to root directory. + # If any of the files finishes with .tt, it's considered to be a template + # and is placed in the destination without the extension .tt. If any + # empty directory is found, it's copied and all .empty_directory files are + # ignored. If any file name is wrapped within % signs, the text within + # the % signs will be executed as a method and replaced with the returned + # value. Let's suppose a doc directory with the following files: + # + # doc/ + # components/.empty_directory + # README + # rdoc.rb.tt + # %app_name%.rb + # + # When invoked as: + # + # directory "doc" + # + # It will create a doc directory in the destination with the following + # files (assuming that the `app_name` method returns the value "blog"): + # + # doc/ + # components/ + # README + # rdoc.rb + # blog.rb + # + # <b>Encoded path note:</b> Since Thor internals use Object#respond_to? to check if it can + # expand %something%, this `something` should be a public method in the class calling + # #directory. If a method is private, Thor stack raises PrivateMethodEncodedError. + # + # ==== Parameters + # source<String>:: the relative path to the source root. + # destination<String>:: the relative path to the destination root. + # config<Hash>:: give :verbose => false to not log the status. + # If :recursive => false, does not look for paths recursively. + # If :mode => :preserve, preserve the file mode from the source. + # If :exclude_pattern => /regexp/, prevents copying files that match that regexp. + # + # ==== Examples + # + # directory "doc" + # directory "doc", "docs", :recursive => false + # + # source://thor-1.2.1/lib/thor/actions/directory.rb:49 + def directory(source, *args, &block); end + + # Creates an empty directory. + # + # ==== Parameters + # destination<String>:: the relative path to the destination root. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # empty_directory "doc" + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:13 + def empty_directory(destination, config = T.unsafe(nil)); end + + # Receives a file or directory and search for it in the source paths. + # + # @raise [Error] + # + # source://thor-1.2.1/lib/thor/actions.rb:133 + def find_in_source_paths(file); end + + # Gets the content at the given address and places it at the given relative + # destination. If a block is given instead of destination, the content of + # the url is yielded and used as location. + # + # +get+ relies on open-uri, so passing application user input would provide + # a command injection attack vector. + # + # ==== Parameters + # source<String>:: the address of the given content. + # destination<String>:: the relative path to the destination root. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # get "http://gist.github.com/103208", "doc/README" + # + # get "http://gist.github.com/103208" do |content| + # content.split("\n").first + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:79 + def get(source, *args, &block); end + + # Run a regular expression replacement on a file. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # flag<Regexp|String>:: the regexp or string to be replaced + # replacement<String>:: the replacement, can be also given as a block + # config<Hash>:: give :verbose => false to not log the status, and + # :force => true, to force the replacement regardles of runner behavior. + # + # ==== Example + # + # gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1' + # + # gsub_file 'README', /rake/, :green do |match| + # match << " no more. Use thor!" + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:265 + def gsub_file(path, flag, *args, &block); end + + # Goes to the root and execute the given block. + # + # source://thor-1.2.1/lib/thor/actions.rb:200 + def in_root; end + + # Injects text right after the class definition. Since it depends on + # insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # klass<String|Class>:: the class to be manipulated + # data<String>:: the data to append to the class, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # inject_into_class "app/controllers/application_controller.rb", "ApplicationController", " filter_parameter :password\n" + # + # inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do + # " filter_parameter :password\n" + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:219 + def inject_into_class(path, klass, *args, &block); end + + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:26 + def inject_into_file(destination, *args, &block); end + + # Injects text right after the module definition. Since it depends on + # insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # module_name<String|Class>:: the module to be manipulated + # data<String>:: the data to append to the class, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", " def help; 'help'; end\n" + # + # inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do + # " def help; 'help'; end\n" + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:242 + def inject_into_module(path, module_name, *args, &block); end + + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:26 + def insert_into_file(destination, *args, &block); end + + # Do something in the root or on a provided subfolder. If a relative path + # is given it's referenced from the current root. The full path is yielded + # to the block you provide. The path is set back to the previous path when + # the method exits. + # + # Returns the value yielded by the block. + # + # ==== Parameters + # dir<String>:: the directory to move to. + # config<Hash>:: give :verbose => true to log and use padding. + # + # source://thor-1.2.1/lib/thor/actions.rb:170 + def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end + + # Links the file from the relative source to the relative destination. If + # the destination is not given it's assumed to be equal to the source. + # + # ==== Parameters + # source<String>:: the relative path to the source root. + # destination<String>:: the relative path to the destination root. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # link_file "README", "doc/README" + # + # link_file "doc/README" + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:51 + def link_file(source, *args); end + + # Prepend text to a file. Since it depends on insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # data<String>:: the data to prepend to the file, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"' + # + # prepend_to_file 'config/environments/test.rb' do + # 'config.gem "rspec"' + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:173 + def prepend_file(path, *args, &block); end + + # Prepend text to a file. Since it depends on insert_into_file, it's reversible. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # data<String>:: the data to prepend to the file, can be also given as a block. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"' + # + # prepend_to_file 'config/environments/test.rb' do + # 'config.gem "rspec"' + # end + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:173 + def prepend_to_file(path, *args, &block); end + + # Returns the given path relative to the absolute root (ie, root where + # the script started). + # + # source://thor-1.2.1/lib/thor/actions.rb:114 + def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end + + # Removes a file at the given location. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # remove_file 'README' + # remove_file 'app/controllers/application_controller.rb' + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:329 + def remove_dir(path, config = T.unsafe(nil)); end + + # Removes a file at the given location. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # remove_file 'README' + # remove_file 'app/controllers/application_controller.rb' + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:329 + def remove_file(path, config = T.unsafe(nil)); end + + # Executes a command returning the contents of the command. + # + # ==== Parameters + # command<String>:: the command to be executed. + # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with + # to append an executable to command execution. + # + # ==== Example + # + # inside('vendor') do + # run('ln -s ~/edge rails') + # end + # + # source://thor-1.2.1/lib/thor/actions.rb:248 + def run(command, config = T.unsafe(nil)); end + + # Executes a ruby script (taking into account WIN32 platform quirks). + # + # ==== Parameters + # command<String>:: the command to be executed. + # config<Hash>:: give :verbose => false to not log the status. + # + # source://thor-1.2.1/lib/thor/actions.rb:285 + def run_ruby_script(command, config = T.unsafe(nil)); end + + # Holds source paths in instance so they can be manipulated. + # + # source://thor-1.2.1/lib/thor/actions.rb:127 + def source_paths; end + + # Gets an ERB template at the relative source, executes it and makes a copy + # at the relative destination. If the destination is not given it's assumed + # to be equal to the source removing .tt from the filename. + # + # ==== Parameters + # source<String>:: the relative path to the source root. + # destination<String>:: the relative path to the destination root. + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Examples + # + # template "README", "doc/README" + # + # template "doc/README" + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:115 + def template(source, *args, &block); end + + # Run a thor command. A hash of options can be given and it's converted to + # switches. + # + # ==== Parameters + # command<String>:: the command to be invoked + # args<Array>:: arguments to the command + # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. + # Other options are given as parameter to Thor. + # + # + # ==== Examples + # + # thor :install, "http://gist.github.com/103208" + # #=> thor install http://gist.github.com/103208 + # + # thor :list, :all => true, :substring => 'rails' + # #=> thor list --all --substring=rails + # + # source://thor-1.2.1/lib/thor/actions.rb:308 + def thor(command, *args); end + + # Uncomment all lines matching a given regex. It will leave the space + # which existed before the comment hash in tact but will remove any spacing + # between the comment hash and the beginning of the line. + # + # ==== Parameters + # path<String>:: path of the file to be changed + # flag<Regexp|String>:: the regexp or string used to decide which lines to uncomment + # config<Hash>:: give :verbose => false to not log the status. + # + # ==== Example + # + # uncomment_lines 'config/initializers/session_store.rb', /active_record/ + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:293 + def uncomment_lines(path, flag, *args); end + + protected + + # source://thor-1.2.1/lib/thor/actions.rb:329 + def _cleanup_options_and_set(options, key); end + + # Allow current root to be shared between invocations. + # + # source://thor-1.2.1/lib/thor/actions.rb:325 + def _shared_configuration; end + + private + + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:350 + def capture(*args); end + + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:346 + def concat(string); end + + # Returns the value of attribute output_buffer. + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:341 + def output_buffer; end + + # Sets the attribute output_buffer + # + # @param value the value to set the attribute output_buffer to. + # + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:341 + def output_buffer=(_arg0); end + + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:354 + def with_output_buffer(buf = T.unsafe(nil)); end + + class << self + # source://thor-1.2.1/lib/thor/actions.rb:12 + def included(base); end + end +end + +# Thor::Actions#capture depends on what kind of buffer is used in ERB. +# Thus CapturableERB fixes ERB to use String buffer. +# +# source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:366 +class Thor::Actions::CapturableERB < ::ERB + # source://thor-1.2.1/lib/thor/actions/file_manipulation.rb:367 + def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end +end + +# source://thor-1.2.1/lib/thor/actions.rb:17 +module Thor::Actions::ClassMethods + # Add runtime options that help actions execution. + # + # source://thor-1.2.1/lib/thor/actions.rb:48 + def add_runtime_options!; end + + # Hold source paths for one Thor instance. source_paths_for_search is the + # method responsible to gather source_paths from this current class, + # inherited paths and the source root. + # + # source://thor-1.2.1/lib/thor/actions.rb:22 + def source_paths; end + + # Returns the source paths in the following order: + # + # 1) This class source paths + # 2) Source root + # 3) Parents source paths + # + # source://thor-1.2.1/lib/thor/actions.rb:38 + def source_paths_for_search; end + + # Stores and return the source root for this class + # + # source://thor-1.2.1/lib/thor/actions.rb:27 + def source_root(path = T.unsafe(nil)); end +end + +# CreateFile is a subset of Template, which instead of rendering a file with +# ERB, it gets the content from the user. +# +# source://thor-1.2.1/lib/thor/actions/create_file.rb:32 +class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory + # @return [CreateFile] a new instance of CreateFile + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:35 + def initialize(base, destination, data, config = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/actions/create_file.rb:33 + def data; end + + # Checks if the content of the file at the destination is identical to the rendered result. + # + # ==== Returns + # Boolean:: true if it is identical, false otherwise. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:45 + def identical?; end + + # source://thor-1.2.1/lib/thor/actions/create_file.rb:59 + def invoke!; end + + # Holds the content to be added to the file. + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:51 + def render; end + + protected + + # Shows the file collision menu to the user and gets the result. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:99 + def force_on_collision?; end + + # If force is true, run the action, otherwise check if it's not being + # skipped. If both are false, show the file_collision menu, if the menu + # returns true, force it, otherwise skip. + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:85 + def force_or_skip_or_conflict(force, skip, &block); end + + # Now on conflict we check if the file is identical or not. + # + # source://thor-1.2.1/lib/thor/actions/create_file.rb:72 + def on_conflict_behavior(&block); end +end + +# CreateLink is a subset of CreateFile, which instead of taking a block of +# data, just takes a source string from the user. +# +# source://thor-1.2.1/lib/thor/actions/create_link.rb:27 +class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile + # source://thor-1.2.1/lib/thor/actions/create_link.rb:28 + def data; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/create_link.rb:56 + def exists?; end + + # Checks if the content of the file at the destination is identical to the rendered result. + # + # ==== Returns + # Boolean:: true if it is identical, false otherwise. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/create_link.rb:35 + def identical?; end + + # source://thor-1.2.1/lib/thor/actions/create_link.rb:40 + def invoke!; end +end + +# source://thor-1.2.1/lib/thor/actions/directory.rb:55 +class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory + # @return [Directory] a new instance of Directory + # + # source://thor-1.2.1/lib/thor/actions/directory.rb:58 + def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end + + # source://thor-1.2.1/lib/thor/actions/directory.rb:64 + def invoke!; end + + # source://thor-1.2.1/lib/thor/actions/directory.rb:69 + def revoke!; end + + # Returns the value of attribute source. + # + # source://thor-1.2.1/lib/thor/actions/directory.rb:56 + def source; end + + protected + + # source://thor-1.2.1/lib/thor/actions/directory.rb:75 + def execute!; end + + # source://thor-1.2.1/lib/thor/actions/directory.rb:99 + def file_level_lookup(previous_lookup); end + + # source://thor-1.2.1/lib/thor/actions/directory.rb:103 + def files(lookup); end +end + +# source://thor-1.2.1/lib/thor/actions/empty_directory.rb:23 +class Thor::Actions::EmptyDirectory + # Initializes given the source and destination. + # + # ==== Parameters + # base<Thor::Base>:: A Thor::Base instance + # source<String>:: Relative path to the source of this file + # destination<String>:: Relative path to the destination of this file + # config<Hash>:: give :verbose => false to not log the status. + # + # @return [EmptyDirectory] a new instance of EmptyDirectory + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:34 + def initialize(base, destination, config = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:24 + def base; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:24 + def config; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:24 + def destination; end + + # Checks if the destination file already exists. + # + # ==== Returns + # Boolean:: true if the file exists, false otherwise. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:45 + def exists?; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:24 + def given_destination; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:49 + def invoke!; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:24 + def relative_destination; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:56 + def revoke!; end + + protected + + # Filenames in the encoded form are converted. If you have a file: + # + # %file_name%.rb + # + # It calls #file_name from the base and replaces %-string with the + # return value (should be String) of #file_name: + # + # user.rb + # + # The method referenced can be either public or private. + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:103 + def convert_encoded_instructions(filename); end + + # Sets the absolute destination value from a relative destination value. + # It also stores the given and relative destination. Let's suppose our + # script is being executed on "dest", it sets the destination root to + # "dest". The destination, given_destination and relative_destination + # are related in the following way: + # + # inside "bar" do + # empty_directory "baz" + # end + # + # destination #=> dest/bar/baz + # relative_destination #=> bar/baz + # given_destination #=> baz + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:85 + def destination=(destination); end + + # Receives a hash of options and just execute the block if some + # conditions are met. + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:113 + def invoke_with_conflict_check(&block); end + + # What to do when the destination file already exists. + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:132 + def on_conflict_behavior; end + + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:126 + def on_file_clash_behavior; end + + # Shortcut for pretend. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:67 + def pretend?; end + + # Shortcut to say_status shell method. + # + # source://thor-1.2.1/lib/thor/actions/empty_directory.rb:138 + def say_status(status, color); end +end + +# source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:36 +class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory + # @return [InjectIntoFile] a new instance of InjectIntoFile + # + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:39 + def initialize(base, destination, data, config); end + + # Returns the value of attribute behavior. + # + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:37 + def behavior; end + + # Returns the value of attribute flag. + # + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:37 + def flag; end + + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:52 + def invoke!; end + + # Returns the value of attribute replacement. + # + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:37 + def replacement; end + + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:72 + def revoke!; end + + protected + + # Adds the content to the file. + # + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:108 + def replace!(regexp, string, force); end + + # source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:88 + def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end +end + +# Injects the given content into a file. Different from gsub_file, this +# method is reversible. +# +# ==== Parameters +# destination<String>:: Relative path to the destination root +# data<String>:: Data to add to the file. Can be given as a block. +# config<Hash>:: give :verbose => false to not log the status and the flag +# for injection (:after or :before) or :force => true for +# insert two or more times the same content. +# +# ==== Examples +# +# insert_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n" +# +# insert_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do +# gems = ask "Which gems would you like to add?" +# gems.split(" ").map{ |gem| " config.gem :#{gem}" }.join("\n") +# end +# +# source://thor-1.2.1/lib/thor/actions/inject_into_file.rb:24 +Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash) + +# source://thor-1.2.1/lib/thor/error.rb:60 +class Thor::AmbiguousCommandError < ::Thor::Error; end + +# source://thor-1.2.1/lib/thor/error.rb:62 +Thor::AmbiguousTaskError = Thor::AmbiguousCommandError + +# source://thor-1.2.1/lib/thor/parser/argument.rb:2 +class Thor::Argument + # @raise [ArgumentError] + # @return [Argument] a new instance of Argument + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:8 + def initialize(name, options = T.unsafe(nil)); end + + # Returns the value of attribute banner. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def banner; end + + # Returns the value of attribute default. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def default; end + + # Returns the value of attribute description. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def description; end + + # Returns the value of attribute enum. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def enum; end + + # Returns the value of attribute name. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def human_name; end + + # Returns the value of attribute name. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def name; end + + # Returns the value of attribute required. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def required; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:31 + def required?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:35 + def show_default?; end + + # Returns the value of attribute type. + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:5 + def type; end + + # source://thor-1.2.1/lib/thor/parser/argument.rb:27 + def usage; end + + protected + + # source://thor-1.2.1/lib/thor/parser/argument.rb:55 + def default_banner; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:51 + def valid_type?(type); end + + # @raise [ArgumentError] + # + # source://thor-1.2.1/lib/thor/parser/argument.rb:46 + def validate!; end +end + +# source://thor-1.2.1/lib/thor/parser/argument.rb:3 +Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array) + +# source://thor-1.2.1/lib/thor/parser/arguments.rb:2 +class Thor::Arguments + # Takes an array of Thor::Argument objects. + # + # @return [Arguments] a new instance of Arguments + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:26 + def initialize(arguments = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/parser/arguments.rb:44 + def parse(args); end + + # source://thor-1.2.1/lib/thor/parser/arguments.rb:57 + def remaining; end + + private + + # Raises an error if @non_assigned_required array is not empty. + # + # @raise [RequiredArgumentMissingError] + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:170 + def check_requirement!; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:88 + def current_is_value?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:68 + def last?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:63 + def no_or_skip?(arg); end + + # Runs through the argument array getting all strings until no string is + # found or a switch is found. + # + # ["a", "b", "c"] + # + # And returns it as an array: + # + # ["a", "b", "c"] + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:122 + def parse_array(name); end + + # Runs through the argument array getting strings that contains ":" and + # mark it as a hash: + # + # [ "name:string", "age:integer" ] + # + # Becomes: + # + # { "name" => "string", "age" => "integer" } + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:101 + def parse_hash(name); end + + # Check if the peek is numeric format and return a Float or Integer. + # Check if the peek is included in enum if enum is provided. + # Otherwise raises an error. + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:133 + def parse_numeric(name); end + + # Parse string: + # for --string-arg, just return the current value in the pile + # for --no-string-arg, nil + # Check if the peek is included in enum if enum is provided. Otherwise raises an error. + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:154 + def parse_string(name); end + + # source://thor-1.2.1/lib/thor/parser/arguments.rb:72 + def peek; end + + # source://thor-1.2.1/lib/thor/parser/arguments.rb:76 + def shift; end + + # source://thor-1.2.1/lib/thor/parser/arguments.rb:80 + def unshift(arg); end + + class << self + # source://thor-1.2.1/lib/thor/parser/arguments.rb:19 + def parse(*args); end + + # Receives an array of args and returns two arrays, one with arguments + # and one with switches. + # + # source://thor-1.2.1/lib/thor/parser/arguments.rb:8 + def split(args); end + end +end + +# source://thor-1.2.1/lib/thor/parser/arguments.rb:3 +Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp) + +# source://thor-1.2.1/lib/thor/shell.rb:4 +module Thor::Base + include ::Thor::Invocation + include ::Thor::Shell + + mixes_in_class_methods ::Thor::Base::ClassMethods + mixes_in_class_methods ::Thor::Invocation::ClassMethods + + # It receives arguments in an Array and two hashes, one for options and + # other for configuration. + # + # Notice that it does not check if all required arguments were supplied. + # It should be done by the parser. + # + # ==== Parameters + # args<Array[Object]>:: An array of objects. The objects are applied to their + # respective accessors declared with <tt>argument</tt>. + # + # options<Hash>:: An options hash that will be available as self.options. + # The hash given is converted to a hash with indifferent + # access, magic predicates (options.skip?) and then frozen. + # + # config<Hash>:: Configuration for this Thor class. + # + # source://thor-1.2.1/lib/thor/base.rb:53 + def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end + + # Returns the value of attribute args. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def args; end + + # Sets the attribute args + # + # @param value the value to set the attribute args to. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def args=(_arg0); end + + # Returns the value of attribute options. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def options; end + + # Sets the attribute options + # + # @param value the value to set the attribute options to. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def options=(_arg0); end + + # Returns the value of attribute parent_options. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def parent_options; end + + # Sets the attribute parent_options + # + # @param value the value to set the attribute parent_options to. + # + # source://thor-1.2.1/lib/thor/base.rb:35 + def parent_options=(_arg0); end + + class << self + # source://thor-1.2.1/lib/thor/base.rb:100 + def included(base); end + + # Whenever a class inherits from Thor or Thor::Group, we should track the + # class and the file on Thor::Base. This is the method responsible for it. + # + # source://thor-1.2.1/lib/thor/base.rb:128 + def register_klass_file(klass); end + + # Returns the shell used in all Thor classes. If you are in a Unix platform + # it will use a colored log, otherwise it will use a basic one without color. + # + # source://thor-1.2.1/lib/thor/shell.rb:11 + def shell; end + + # Sets the attribute shell + # + # @param value the value to set the attribute shell to. + # + # source://thor-1.2.1/lib/thor/shell.rb:6 + def shell=(_arg0); end + + # Returns the files where the subclasses are kept. + # + # ==== Returns + # Hash[path<String> => Class] + # + # source://thor-1.2.1/lib/thor/base.rb:121 + def subclass_files; end + + # Returns the classes that inherits from Thor or Thor::Group. + # + # ==== Returns + # Array[Class] + # + # source://thor-1.2.1/lib/thor/base.rb:112 + def subclasses; end + end +end + +# source://thor-1.2.1/lib/thor/base.rb:137 +module Thor::Base::ClassMethods + # Returns the commands for this Thor class and all subclasses. + # + # ==== Returns + # Hash:: An ordered hash with commands names as keys and Thor::Command + # objects as values. + # + # source://thor-1.2.1/lib/thor/base.rb:383 + def all_commands; end + + # Returns the commands for this Thor class and all subclasses. + # + # ==== Returns + # Hash:: An ordered hash with commands names as keys and Thor::Command + # objects as values. + # + # source://thor-1.2.1/lib/thor/base.rb:383 + def all_tasks; end + + # If you want to use defaults that don't match the type of an option, + # either specify `check_default_type: false` or call `allow_incompatible_default_type!` + # + # source://thor-1.2.1/lib/thor/base.rb:173 + def allow_incompatible_default_type!; end + + # Adds an argument to the class and creates an attr_accessor for it. + # + # Arguments are different from options in several aspects. The first one + # is how they are parsed from the command line, arguments are retrieved + # from position: + # + # thor command NAME + # + # Instead of: + # + # thor command --name=NAME + # + # Besides, arguments are used inside your code as an accessor (self.argument), + # while options are all kept in a hash (self.options). + # + # Finally, arguments cannot have type :default or :boolean but can be + # optional (supplying :optional => :true or :required => false), although + # you cannot have a required argument after a non-required argument. If you + # try it, an error is raised. + # + # ==== Parameters + # name<Symbol>:: The name of the argument. + # options<Hash>:: Described below. + # + # ==== Options + # :desc - Description for the argument. + # :required - If the argument is required or not. + # :optional - If the argument is optional or not. + # :type - The type of the argument, can be :string, :hash, :array, :numeric. + # :default - Default value for this argument. It cannot be required and have default values. + # :banner - String to show on usage notes. + # + # ==== Errors + # ArgumentError:: Raised if you supply a required argument after a non required one. + # + # source://thor-1.2.1/lib/thor/base.rb:245 + def argument(name, options = T.unsafe(nil)); end + + # Returns this class arguments, looking up in the ancestors chain. + # + # ==== Returns + # Array[Thor::Argument] + # + # source://thor-1.2.1/lib/thor/base.rb:277 + def arguments; end + + # source://thor-1.2.1/lib/thor/base.rb:146 + def attr_accessor(*_arg0); end + + # source://thor-1.2.1/lib/thor/base.rb:138 + def attr_reader(*_arg0); end + + # source://thor-1.2.1/lib/thor/base.rb:142 + def attr_writer(*_arg0); end + + # source://thor-1.2.1/lib/thor/base.rb:177 + def check_default_type; end + + # If you want to raise an error when the default value of an option does not match + # the type call check_default_type! + # This will be the default; for compatibility a deprecation warning is issued if necessary. + # + # source://thor-1.2.1/lib/thor/base.rb:167 + def check_default_type!; end + + # source://thor-1.2.1/lib/thor/base.rb:156 + def check_unknown_options; end + + # If you want to raise an error for unknown options, call check_unknown_options! + # This is disabled by default to allow dynamic invocations. + # + # source://thor-1.2.1/lib/thor/base.rb:152 + def check_unknown_options!; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:160 + def check_unknown_options?(config); end + + # Adds an option to the set of class options + # + # ==== Parameters + # name<Symbol>:: The name of the argument. + # options<Hash>:: Described below. + # + # ==== Options + # :desc:: -- Description for the argument. + # :required:: -- If the argument is required or not. + # :default:: -- Default value for this argument. + # :group:: -- The group for this options. Use by class options to output options in different levels. + # :aliases:: -- Aliases for this option. <b>Note:</b> Thor follows a convention of one-dash-one-letter options. Thus aliases like "-something" wouldn't be parsed; use either "\--something" or "-s" instead. + # :type:: -- The type of the argument, can be :string, :hash, :array, :numeric or :boolean. + # :banner:: -- String to show on usage notes. + # :hide:: -- If you want to hide this option from the help. + # + # source://thor-1.2.1/lib/thor/base.rb:312 + def class_option(name, options = T.unsafe(nil)); end + + # Adds a bunch of options to the set of class options. + # + # class_options :foo => false, :bar => :required, :baz => :string + # + # If you prefer more detailed declaration, check class_option. + # + # ==== Parameters + # Hash[Symbol => Object] + # + # source://thor-1.2.1/lib/thor/base.rb:290 + def class_options(options = T.unsafe(nil)); end + + # Returns the commands for this Thor class. + # + # ==== Returns + # Hash:: An ordered hash with commands names as keys and Thor::Command + # objects as values. + # + # source://thor-1.2.1/lib/thor/base.rb:372 + def commands; end + + # If true, option set will not suspend the execution of the command when + # a required option is not provided. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:191 + def disable_required_check?(command_name); end + + # A flag that makes the process exit with status 1 if any error happens. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:529 + def exit_on_failure?; end + + # Defines the group. This is used when thor list is invoked so you can specify + # that only commands from a pre-defined group will be shown. Defaults to standard. + # + # ==== Parameters + # name<String|Symbol> + # + # source://thor-1.2.1/lib/thor/base.rb:358 + def group(name = T.unsafe(nil)); end + + # @raise [InvocationError] + # + # source://thor-1.2.1/lib/thor/base.rb:519 + def handle_argument_error(command, error, args, arity); end + + # @raise [UndefinedCommandError] + # + # source://thor-1.2.1/lib/thor/base.rb:514 + def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end + + # @raise [UndefinedCommandError] + # + # source://thor-1.2.1/lib/thor/base.rb:514 + def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end + + # Sets the namespace for the Thor or Thor::Group class. By default the + # namespace is retrieved from the class name. If your Thor class is named + # Scripts::MyScript, the help method, for example, will be called as: + # + # thor scripts:my_script -h + # + # If you change the namespace: + # + # namespace :my_scripts + # + # You change how your commands are invoked: + # + # thor my_scripts -h + # + # Finally, if you change your namespace to default: + # + # namespace :default + # + # Your commands can be invoked with a shortcut. Instead of: + # + # thor :my_command + # + # source://thor-1.2.1/lib/thor/base.rb:467 + def namespace(name = T.unsafe(nil)); end + + # All methods defined inside the given block are not added as commands. + # + # So you can do: + # + # class MyScript < Thor + # no_commands do + # def this_is_not_a_command + # end + # end + # end + # + # You can also add the method and remove it from the command list: + # + # class MyScript < Thor + # def this_is_not_a_command + # end + # remove_command :this_is_not_a_command + # end + # + # source://thor-1.2.1/lib/thor/base.rb:431 + def no_commands(&block); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:441 + def no_commands?; end + + # source://thor-1.2.1/lib/thor/base.rb:437 + def no_commands_context; end + + # All methods defined inside the given block are not added as commands. + # + # So you can do: + # + # class MyScript < Thor + # no_commands do + # def this_is_not_a_command + # end + # end + # end + # + # You can also add the method and remove it from the command list: + # + # class MyScript < Thor + # def this_is_not_a_command + # end + # remove_command :this_is_not_a_command + # end + # + # source://thor-1.2.1/lib/thor/base.rb:431 + def no_tasks(&block); end + + # Allows to use private methods from parent in child classes as commands. + # + # ==== Parameters + # names<Array>:: Method names to be used as commands + # + # ==== Examples + # + # public_command :foo + # public_command :foo, :bar, :baz + # + # source://thor-1.2.1/lib/thor/base.rb:507 + def public_command(*names); end + + # Allows to use private methods from parent in child classes as commands. + # + # ==== Parameters + # names<Array>:: Method names to be used as commands + # + # ==== Examples + # + # public_command :foo + # public_command :foo, :bar, :baz + # + # source://thor-1.2.1/lib/thor/base.rb:507 + def public_task(*names); end + + # Removes a previous defined argument. If :undefine is given, undefine + # accessors as well. + # + # ==== Parameters + # names<Array>:: Arguments to be removed + # + # ==== Examples + # + # remove_argument :foo + # remove_argument :foo, :bar, :baz, :undefine => true + # + # source://thor-1.2.1/lib/thor/base.rb:327 + def remove_argument(*names); end + + # Removes a previous defined class option. + # + # ==== Parameters + # names<Array>:: Class options to be removed + # + # ==== Examples + # + # remove_class_option :foo + # remove_class_option :foo, :bar, :baz + # + # source://thor-1.2.1/lib/thor/base.rb:346 + def remove_class_option(*names); end + + # Removes a given command from this Thor class. This is usually done if you + # are inheriting from another class and don't want it to be available + # anymore. + # + # By default it only remove the mapping to the command. But you can supply + # :undefine => true to undefine the method from the class as well. + # + # ==== Parameters + # name<Symbol|String>:: The name of the command to be removed + # options<Hash>:: You can give :undefine => true if you want commands the method + # to be undefined from the class as well. + # + # source://thor-1.2.1/lib/thor/base.rb:401 + def remove_command(*names); end + + # Removes a given command from this Thor class. This is usually done if you + # are inheriting from another class and don't want it to be available + # anymore. + # + # By default it only remove the mapping to the command. But you can supply + # :undefine => true to undefine the method from the class as well. + # + # ==== Parameters + # name<Symbol|String>:: The name of the command to be removed + # options<Hash>:: You can give :undefine => true if you want commands the method + # to be undefined from the class as well. + # + # source://thor-1.2.1/lib/thor/base.rb:401 + def remove_task(*names); end + + # Parses the command and options from the given args, instantiate the class + # and invoke the command. This method is used when the arguments must be parsed + # from an array. If you are inside Ruby and want to use a Thor class, you + # can simply initialize it: + # + # script = MyScript.new(args, options, config) + # script.invoke(:command, first_arg, second_arg, third_arg) + # + # source://thor-1.2.1/lib/thor/base.rb:483 + def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end + + # If true, option parsing is suspended as soon as an unknown option or a + # regular argument is encountered. All remaining arguments are passed to + # the command as regular arguments. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:185 + def stop_on_unknown_option?(command_name); end + + # source://thor-1.2.1/lib/thor/base.rb:202 + def strict_args_position; end + + # If you want only strict string args (useful when cascading thor classes), + # call strict_args_position! This is disabled by default to allow dynamic + # invocations. + # + # source://thor-1.2.1/lib/thor/base.rb:198 + def strict_args_position!; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:206 + def strict_args_position?(config); end + + # Returns the commands for this Thor class. + # + # ==== Returns + # Hash:: An ordered hash with commands names as keys and Thor::Command + # objects as values. + # + # source://thor-1.2.1/lib/thor/base.rb:372 + def tasks; end + + protected + + # SIGNATURE: Sets the baseclass. This is where the superclass lookup + # finishes. + # + # source://thor-1.2.1/lib/thor/base.rb:679 + def baseclass; end + + # The basename of the program invoking the thor class. + # + # source://thor-1.2.1/lib/thor/base.rb:673 + def basename; end + + # Build an option and adds it to the given scope. + # + # ==== Parameters + # name<Symbol>:: The name of the argument. + # options<Hash>:: Described in both class_option and method_option. + # scope<Hash>:: Options hash that is being built up + # + # source://thor-1.2.1/lib/thor/base.rb:590 + def build_option(name, options, scope); end + + # Receives a hash of options, parse them and add to the scope. This is a + # fast way to set a bunch of options: + # + # build_options :foo => true, :bar => :required, :baz => :string + # + # ==== Parameters + # Hash[Symbol => Object] + # + # source://thor-1.2.1/lib/thor/base.rb:601 + def build_options(options, scope); end + + # Prints the class options per group. If an option does not belong to + # any group, it's printed as Class option. + # + # source://thor-1.2.1/lib/thor/base.rb:539 + def class_options_help(shell, groups = T.unsafe(nil)); end + + # SIGNATURE: Creates a new command if valid_command? is true. This method is + # called when a new method is added to the class. + # + # source://thor-1.2.1/lib/thor/base.rb:684 + def create_command(meth); end + + # SIGNATURE: Creates a new command if valid_command? is true. This method is + # called when a new method is added to the class. + # + # source://thor-1.2.1/lib/thor/base.rb:684 + def create_task(meth); end + + # SIGNATURE: The hook invoked by start. + # + # @raise [NotImplementedError] + # + # source://thor-1.2.1/lib/thor/base.rb:694 + def dispatch(command, given_args, given_opts, config); end + + # Finds a command with the given name. If the command belongs to the current + # class, just return it, otherwise dup it and add the fresh copy to the + # current command hash. + # + # source://thor-1.2.1/lib/thor/base.rb:610 + def find_and_refresh_command(name); end + + # Finds a command with the given name. If the command belongs to the current + # class, just return it, otherwise dup it and add the fresh copy to the + # current command hash. + # + # source://thor-1.2.1/lib/thor/base.rb:610 + def find_and_refresh_task(name); end + + # Retrieves a value from superclass. If it reaches the baseclass, + # returns default. + # + # source://thor-1.2.1/lib/thor/base.rb:651 + def from_superclass(method, default = T.unsafe(nil)); end + + # Everytime someone inherits from a Thor class, register the klass + # and file into baseclass. + # + # source://thor-1.2.1/lib/thor/base.rb:623 + def inherited(klass); end + + # SIGNATURE: Defines behavior when the initialize method is added to the + # class. + # + # source://thor-1.2.1/lib/thor/base.rb:690 + def initialize_added; end + + # Raises an error if the word given is a Thor reserved word. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/base.rb:579 + def is_thor_reserved_word?(word, type); end + + # Fire this callback whenever a method is added. Added methods are + # tracked as commands by invoking the create_command method. + # + # source://thor-1.2.1/lib/thor/base.rb:631 + def method_added(meth); end + + # Receives a set of options and print them. + # + # source://thor-1.2.1/lib/thor/base.rb:557 + def print_options(shell, options, group_name = T.unsafe(nil)); end +end + +# source://thor-1.2.1/lib/thor/command.rb:2 +class Thor::Command < ::Struct + # @return [Command] a new instance of Command + # + # source://thor-1.2.1/lib/thor/command.rb:5 + def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end + + # Returns the formatted usage by injecting given required arguments + # and required options into the given usage. + # + # source://thor-1.2.1/lib/thor/command.rb:41 + def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:14 + def hidden?; end + + # By default, a command invokes a method in the thor class. You can change this + # implementation to create custom commands. + # + # source://thor-1.2.1/lib/thor/command.rb:20 + def run(instance, args = T.unsafe(nil)); end + + protected + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:105 + def handle_argument_error?(instance, error, caller); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:112 + def handle_no_method_error?(instance, error, caller); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:95 + def local_method?(instance, name); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:78 + def not_debugging?(instance); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:91 + def private_method?(instance); end + + # Given a target, checks if this class name is a public method. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:87 + def public_method?(instance); end + + # Add usage with required arguments + # + # source://thor-1.2.1/lib/thor/command.rb:68 + def required_arguments_for(klass, usage); end + + # source://thor-1.2.1/lib/thor/command.rb:82 + def required_options; end + + # source://thor-1.2.1/lib/thor/command.rb:100 + def sans_backtrace(backtrace, caller); end + + private + + # source://thor-1.2.1/lib/thor/command.rb:9 + def initialize_copy(other); end +end + +# source://thor-1.2.1/lib/thor/command.rb:3 +Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:2 +module Thor::CoreExt; end + +# A hash with indifferent access and magic predicates. +# +# hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true +# +# hash[:foo] #=> 'bar' +# hash['foo'] #=> 'bar' +# hash.foo? #=> true +# +# source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:11 +class Thor::CoreExt::HashWithIndifferentAccess < ::Hash + # @return [HashWithIndifferentAccess] a new instance of HashWithIndifferentAccess + # + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:12 + def initialize(hash = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:19 + def [](key); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:23 + def []=(key, value); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:27 + def delete(key); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:31 + def except(*keys); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:37 + def fetch(key, *args); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:41 + def key?(key); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:49 + def merge(other); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:53 + def merge!(other); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:68 + def replace(other_hash); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:60 + def reverse_merge(other); end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:64 + def reverse_merge!(other_hash); end + + # Convert to a Hash with String keys. + # + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:73 + def to_hash; end + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:45 + def values_at(*indices); end + + protected + + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:79 + def convert_key(key); end + + # Magic predicates. For instance: + # + # options.force? # => !!options['force'] + # options.shebang # => "/usr/lib/local/ruby" + # options.test_framework?(:rspec) # => options[:test_framework] == :rspec + # + # source://thor-1.2.1/lib/thor/core_ext/hash_with_indifferent_access.rb:89 + def method_missing(method, *args); end +end + +# source://thor-1.2.1/lib/thor/error.rb:2 +Thor::Correctable = DidYouMean::Correctable + +# A dynamic command that handles method missing scenarios. +# +# source://thor-1.2.1/lib/thor/command.rb:128 +class Thor::DynamicCommand < ::Thor::Command + # @return [DynamicCommand] a new instance of DynamicCommand + # + # source://thor-1.2.1/lib/thor/command.rb:129 + def initialize(name, options = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/command.rb:133 + def run(instance, args = T.unsafe(nil)); end +end + +# source://thor-1.2.1/lib/thor/command.rb:141 +Thor::DynamicTask = Thor::DynamicCommand + +# Thor::Error is raised when it's caused by wrong usage of thor classes. Those +# errors have their backtrace suppressed and are nicely shown to the user. +# +# Errors that are caused by the developer, like declaring a method which +# overwrites a thor keyword, SHOULD NOT raise a Thor::Error. This way, we +# ensure that developer errors are shown with full backtrace. +# +# source://thor-1.2.1/lib/thor/error.rb:23 +class Thor::Error < ::StandardError; end + +# Thor has a special class called Thor::Group. The main difference to Thor class +# is that it invokes all commands at once. It also include some methods that allows +# invocations to be done at the class method, which are not available to Thor +# commands. +# +# source://thor-1.2.1/lib/thor/group.rb:7 +class Thor::Group + include ::Thor::Base + include ::Thor::Invocation + include ::Thor::Shell + extend ::Thor::Base::ClassMethods + extend ::Thor::Invocation::ClassMethods + + protected + + # Shortcut to invoke with padding and block handling. Use internally by + # invoke and invoke_from_option class methods. + # + # source://thor-1.2.1/lib/thor/group.rb:265 + def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end + + class << self + # Overwrite class options help to allow invoked generators options to be + # shown recursively when invoking a generator. + # + # source://thor-1.2.1/lib/thor/group.rb:161 + def class_options_help(shell, groups = T.unsafe(nil)); end + + # The description for this Thor::Group. If none is provided, but a source root + # exists, tries to find the USAGE one folder above it, otherwise searches + # in the superclass. + # + # ==== Parameters + # description<String>:: The description for this Thor::Group. + # + # source://thor-1.2.1/lib/thor/group.rb:16 + def desc(description = T.unsafe(nil)); end + + # Get invocations array and merge options from invocations. Those + # options are added to group_options hash. Options that already exists + # in base_options are not added twice. + # + # source://thor-1.2.1/lib/thor/group.rb:172 + def get_options_from_invocations(group_options, base_options); end + + # @raise [error] + # + # source://thor-1.2.1/lib/thor/group.rb:207 + def handle_argument_error(command, error, _args, arity); end + + # Prints help information. + # + # ==== Options + # short:: When true, shows only usage. + # + # source://thor-1.2.1/lib/thor/group.rb:29 + def help(shell); end + + # Stores invocation blocks used on invoke_from_option. + # + # source://thor-1.2.1/lib/thor/group.rb:45 + def invocation_blocks; end + + # Stores invocations for this class merging with superclass values. + # + # source://thor-1.2.1/lib/thor/group.rb:39 + def invocations; end + + # Invoke the given namespace or class given. It adds an instance + # method that will invoke the klass and command. You can give a block to + # configure how it will be invoked. + # + # The namespace/class given will have its options showed on the help + # usage. Check invoke_from_option for more information. + # + # source://thor-1.2.1/lib/thor/group.rb:56 + def invoke(*names, &block); end + + # Invoke a thor class based on the value supplied by the user to the + # given option named "name". A class option must be created before this + # method is invoked for each name given. + # + # ==== Examples + # + # class GemGenerator < Thor::Group + # class_option :test_framework, :type => :string + # invoke_from_option :test_framework + # end + # + # ==== Boolean options + # + # In some cases, you want to invoke a thor class if some option is true or + # false. This is automatically handled by invoke_from_option. Then the + # option name is used to invoke the generator. + # + # ==== Preparing for invocation + # + # In some cases you want to customize how a specified hook is going to be + # invoked. You can do that by overwriting the class method + # prepare_for_invocation. The class method must necessarily return a klass + # and an optional command. + # + # ==== Custom invocations + # + # You can also supply a block to customize how the option is going to be + # invoked. The block receives two parameters, an instance of the current + # class and the klass to be invoked. + # + # source://thor-1.2.1/lib/thor/group.rb:110 + def invoke_from_option(*names, &block); end + + # Returns commands ready to be printed. + # + # source://thor-1.2.1/lib/thor/group.rb:199 + def printable_commands(*_arg0); end + + # Returns commands ready to be printed. + # + # source://thor-1.2.1/lib/thor/group.rb:199 + def printable_tasks(*_arg0); end + + # Remove a previously added invocation. + # + # ==== Examples + # + # remove_invocation :test_framework + # + # source://thor-1.2.1/lib/thor/group.rb:149 + def remove_invocation(*names); end + + protected + + # The banner for this class. You can customize it if you are invoking the + # thor class by another ways which is not the Thor::Runner. + # + # source://thor-1.2.1/lib/thor/group.rb:238 + def banner; end + + # source://thor-1.2.1/lib/thor/group.rb:248 + def baseclass; end + + # source://thor-1.2.1/lib/thor/group.rb:252 + def create_command(meth); end + + # source://thor-1.2.1/lib/thor/group.rb:252 + def create_task(meth); end + + # The method responsible for dispatching given the args. + # + # @yield [instance] + # + # source://thor-1.2.1/lib/thor/group.rb:217 + def dispatch(command, given_args, given_opts, config); end + + # Represents the whole class as a command. + # + # source://thor-1.2.1/lib/thor/group.rb:243 + def self_command; end + + # Represents the whole class as a command. + # + # source://thor-1.2.1/lib/thor/group.rb:243 + def self_task; end + end +end + +# Shortcuts for help. +# +# source://thor-1.2.1/lib/thor/base.rb:17 +Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array) + +# A command that is hidden in help messages but still invocable. +# +# source://thor-1.2.1/lib/thor/command.rb:120 +class Thor::HiddenCommand < ::Thor::Command + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/command.rb:121 + def hidden?; end +end + +# source://thor-1.2.1/lib/thor/command.rb:125 +Thor::HiddenTask = Thor::HiddenCommand + +# source://thor-1.2.1/lib/thor/invocation.rb:2 +module Thor::Invocation + mixes_in_class_methods ::Thor::Invocation::ClassMethods + + # Make initializer aware of invocations and the initialization args. + # + # source://thor-1.2.1/lib/thor/invocation.rb:23 + def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end + + # Make the current command chain accessible with in a Thor-(sub)command + # + # source://thor-1.2.1/lib/thor/invocation.rb:30 + def current_command_chain; end + + # Receives a name and invokes it. The name can be a string (either "command" or + # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the + # command cannot be guessed by name, it can also be supplied as second argument. + # + # You can also supply the arguments, options and configuration values for + # the command to be invoked, if none is given, the same values used to + # initialize the invoker are used to initialize the invoked. + # + # When no name is given, it will invoke the default command of the current class. + # + # ==== Examples + # + # class A < Thor + # def foo + # invoke :bar + # invoke "b:hello", ["Erik"] + # end + # + # def bar + # invoke "b:hello", ["Erik"] + # end + # end + # + # class B < Thor + # def hello(name) + # puts "hello #{name}" + # end + # end + # + # You can notice that the method "foo" above invokes two commands: "bar", + # which belongs to the same class and "hello" which belongs to the class B. + # + # By using an invocation system you ensure that a command is invoked only once. + # In the example above, invoking "foo" will invoke "b:hello" just once, even + # if it's invoked later by "bar" method. + # + # When class A invokes class B, all arguments used on A initialization are + # supplied to B. This allows lazy parse of options. Let's suppose you have + # some rspec commands: + # + # class Rspec < Thor::Group + # class_option :mock_framework, :type => :string, :default => :rr + # + # def invoke_mock_framework + # invoke "rspec:#{options[:mock_framework]}" + # end + # end + # + # As you noticed, it invokes the given mock framework, which might have its + # own options: + # + # class Rspec::RR < Thor::Group + # class_option :style, :type => :string, :default => :mock + # end + # + # Since it's not rspec concern to parse mock framework options, when RR + # is invoked all options are parsed again, so RR can extract only the options + # that it's going to use. + # + # If you want Rspec::RR to be initialized with its own set of options, you + # have to do that explicitly: + # + # invoke "rspec:rr", [], :style => :foo + # + # Besides giving an instance, you can also give a class to invoke: + # + # invoke Rspec::RR, [], :style => :foo + # + # source://thor-1.2.1/lib/thor/invocation.rb:102 + def invoke(name = T.unsafe(nil), *args); end + + # Invoke all commands for the current instance. + # + # source://thor-1.2.1/lib/thor/invocation.rb:133 + def invoke_all; end + + # Invoke the given command if the given args. + # + # source://thor-1.2.1/lib/thor/invocation.rb:122 + def invoke_command(command, *args); end + + # Invoke the given command if the given args. + # + # source://thor-1.2.1/lib/thor/invocation.rb:122 + def invoke_task(command, *args); end + + # Invokes using shell padding. + # + # source://thor-1.2.1/lib/thor/invocation.rb:138 + def invoke_with_padding(*args); end + + protected + + # Initialize klass using values stored in the @_initializer. + # + # source://thor-1.2.1/lib/thor/invocation.rb:166 + def _parse_initialization_options(args, opts, config); end + + # This method simply retrieves the class and command to be invoked. + # If the name is nil or the given name is a command in the current class, + # use the given name and return self as class. Otherwise, call + # prepare_for_invocation in the current class. + # + # source://thor-1.2.1/lib/thor/invocation.rb:153 + def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end + + # This method simply retrieves the class and command to be invoked. + # If the name is nil or the given name is a command in the current class, + # use the given name and return self as class. Otherwise, call + # prepare_for_invocation in the current class. + # + # source://thor-1.2.1/lib/thor/invocation.rb:153 + def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end + + # Configuration values that are shared between invocations. + # + # source://thor-1.2.1/lib/thor/invocation.rb:145 + def _shared_configuration; end + + class << self + # source://thor-1.2.1/lib/thor/invocation.rb:3 + def included(base); end + end +end + +# source://thor-1.2.1/lib/thor/invocation.rb:8 +module Thor::Invocation::ClassMethods + # This method is responsible for receiving a name and find the proper + # class and command for it. The key is an optional parameter which is + # available only in class methods invocations (i.e. in Thor::Group). + # + # source://thor-1.2.1/lib/thor/invocation.rb:12 + def prepare_for_invocation(key, name); end +end + +# Raised when a command was found, but not invoked properly. +# +# source://thor-1.2.1/lib/thor/error.rb:65 +class Thor::InvocationError < ::Thor::Error; end + +# source://thor-1.2.1/lib/thor/line_editor/basic.rb:2 +module Thor::LineEditor + class << self + # source://thor-1.2.1/lib/thor/line_editor.rb:10 + def best_available; end + + # source://thor-1.2.1/lib/thor/line_editor.rb:6 + def readline(prompt, options = T.unsafe(nil)); end + end +end + +# source://thor-1.2.1/lib/thor/line_editor/basic.rb:3 +class Thor::LineEditor::Basic + # @return [Basic] a new instance of Basic + # + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:10 + def initialize(prompt, options); end + + # Returns the value of attribute options. + # + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:4 + def options; end + + # Returns the value of attribute prompt. + # + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:4 + def prompt; end + + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:15 + def readline; end + + private + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:32 + def echo?; end + + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:22 + def get_input; end + + class << self + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/line_editor/basic.rb:6 + def available?; end + end +end + +# source://thor-1.2.1/lib/thor/line_editor/readline.rb:3 +class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:13 + def readline; end + + private + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:28 + def add_to_history?; end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:42 + def completion_options; end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:32 + def completion_proc; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:46 + def use_path_completion?; end + + class << self + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:4 + def available?; end + end +end + +# source://thor-1.2.1/lib/thor/line_editor/readline.rb:50 +class Thor::LineEditor::Readline::PathCompletion + # @return [PathCompletion] a new instance of PathCompletion + # + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:54 + def initialize(text); end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:58 + def matches; end + + private + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:68 + def absolute_matches; end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:82 + def base_path; end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:78 + def glob_pattern; end + + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:64 + def relative_matches; end + + # Returns the value of attribute text. + # + # source://thor-1.2.1/lib/thor/line_editor/readline.rb:51 + def text; end +end + +# source://thor-1.2.1/lib/thor/error.rb:101 +class Thor::MalformattedArgumentError < ::Thor::InvocationError; end + +# source://thor-1.2.1/lib/thor/nested_context.rb:2 +class Thor::NestedContext + # @return [NestedContext] a new instance of NestedContext + # + # source://thor-1.2.1/lib/thor/nested_context.rb:3 + def initialize; end + + # source://thor-1.2.1/lib/thor/nested_context.rb:7 + def enter; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/nested_context.rb:15 + def entered?; end + + private + + # source://thor-1.2.1/lib/thor/nested_context.rb:25 + def pop; end + + # source://thor-1.2.1/lib/thor/nested_context.rb:21 + def push; end +end + +# source://thor-1.2.1/lib/thor/error.rb:8 +class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker + # source://thor-1.2.1/lib/thor/error.rb:9 + def initialize(dictionary); end +end + +# source://thor-1.2.1/lib/thor/parser/option.rb:2 +class Thor::Option < ::Thor::Argument + # @return [Option] a new instance of Option + # + # source://thor-1.2.1/lib/thor/parser/option.rb:7 + def initialize(name, options = T.unsafe(nil)); end + + # Returns the value of attribute aliases. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:3 + def aliases; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:105 + def array?; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:105 + def boolean?; end + + # Returns the value of attribute group. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:3 + def group; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:105 + def hash?; end + + # Returns the value of attribute hide. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:3 + def hide; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:79 + def human_name; end + + # Returns the value of attribute lazy_default. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:3 + def lazy_default; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:105 + def numeric?; end + + # Returns the value of attribute repeatable. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:3 + def repeatable; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:105 + def string?; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:75 + def switch_name; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:83 + def usage(padding = T.unsafe(nil)); end + + protected + + # source://thor-1.2.1/lib/thor/parser/option.rb:155 + def dasherize(str); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/option.rb:147 + def dasherized?; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:151 + def undasherize(str); end + + # @raise [ArgumentError] + # + # source://thor-1.2.1/lib/thor/parser/option.rb:113 + def validate!; end + + # source://thor-1.2.1/lib/thor/parser/option.rb:118 + def validate_default_type!; end + + class << self + # This parse quick options given as method_options. It makes several + # assumptions, but you can be more specific using the option method. + # + # parse :foo => "bar" + # #=> Option foo with default value bar + # + # parse [:foo, :baz] => "bar" + # #=> Option foo with default value bar and alias :baz + # + # parse :foo => :required + # #=> Required option foo without default value + # + # parse :foo => 2 + # #=> Option foo with default value 2 and type numeric + # + # parse :foo => :numeric + # #=> Option foo without default value and type numeric + # + # parse :foo => true + # #=> Option foo with default value true and type boolean + # + # The valid types are :boolean, :numeric, :hash, :array and :string. If none + # is given a default type is assumed. This default type accepts arguments as + # string (--foo=value) or booleans (just --foo). + # + # By default all options are optional, unless :required is given. + # + # source://thor-1.2.1/lib/thor/parser/option.rb:45 + def parse(key, value); end + end +end + +# source://thor-1.2.1/lib/thor/parser/option.rb:5 +Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array) + +# source://thor-1.2.1/lib/thor/parser/options.rb:2 +class Thor::Options < ::Thor::Arguments + # Takes a hash of Thor::Option and a hash with defaults. + # + # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters + # an unknown option or a regular argument. + # + # @return [Options] a new instance of Options + # + # source://thor-1.2.1/lib/thor/parser/options.rb:32 + def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end + + # @raise [UnknownArgumentError] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:141 + def check_unknown!; end + + # source://thor-1.2.1/lib/thor/parser/options.rb:88 + def parse(args); end + + # source://thor-1.2.1/lib/thor/parser/options.rb:64 + def peek; end + + # source://thor-1.2.1/lib/thor/parser/options.rb:60 + def remaining; end + + # source://thor-1.2.1/lib/thor/parser/options.rb:78 + def shift; end + + # source://thor-1.2.1/lib/thor/parser/options.rb:83 + def unshift(arg, is_value: T.unsafe(nil)); end + + protected + + # source://thor-1.2.1/lib/thor/parser/options.rb:151 + def assign_result!(option, result); end + + # Check if the current value in peek is a registered switch. + # + # Two booleans are returned. The first is true if the current value + # starts with a hyphen; the second is true if it is a registered switch. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:165 + def current_is_switch?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:177 + def current_is_switch_formatted?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:187 + def current_is_value?; end + + # Check if the given argument is actually a shortcut. + # + # source://thor-1.2.1/lib/thor/parser/options.rb:206 + def normalize_switch(arg); end + + # Parse boolean values which can be given as --foo=true, --foo or --no-foo. + # + # source://thor-1.2.1/lib/thor/parser/options.rb:217 + def parse_boolean(switch); end + + # Parse the value at the peek analyzing if it requires an input or not. + # + # source://thor-1.2.1/lib/thor/parser/options.rb:235 + def parse_peek(switch, option); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:210 + def parsing_options?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/parser/options.rb:192 + def switch?(arg); end + + # source://thor-1.2.1/lib/thor/parser/options.rb:196 + def switch_option(arg); end + + class << self + # Receives a hash and makes it switches. + # + # source://thor-1.2.1/lib/thor/parser/options.rb:11 + def to_switches(options); end + end +end + +# source://thor-1.2.1/lib/thor/parser/options.rb:5 +Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp) + +# source://thor-1.2.1/lib/thor/parser/options.rb:3 +Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp) + +# source://thor-1.2.1/lib/thor/parser/options.rb:8 +Thor::Options::OPTS_END = T.let(T.unsafe(nil), String) + +# source://thor-1.2.1/lib/thor/parser/options.rb:7 +Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp) + +# source://thor-1.2.1/lib/thor/parser/options.rb:4 +Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp) + +# Allow either -x -v or -xv style for single char args +# +# source://thor-1.2.1/lib/thor/parser/options.rb:6 +Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp) + +# Adds a compatibility layer to your Thor classes which allows you to use +# rake package tasks. For example, to use rspec rake tasks, one can do: +# +# require 'thor/rake_compat' +# require 'rspec/core/rake_task' +# +# class Default < Thor +# include Thor::RakeCompat +# +# RSpec::Core::RakeTask.new(:spec) do |t| +# t.spec_opts = ['--options', './.rspec'] +# t.spec_files = FileList['spec/**/*_spec.rb'] +# end +# end +# +# source://thor-1.2.1/lib/thor/rake_compat.rb:20 +module Thor::RakeCompat + include ::FileUtils::StreamUtils_ + include ::FileUtils + include ::Rake::FileUtilsExt + include ::Rake::DSL + + class << self + # @private + # + # source://thor-1.2.1/lib/thor/rake_compat.rb:27 + def included(base); end + + # source://thor-1.2.1/lib/thor/rake_compat.rb:23 + def rake_classes; end + end +end + +# source://thor-1.2.1/lib/thor/error.rb:98 +class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end + +# source://thor-1.2.1/lib/thor/util.rb:4 +module Thor::Sandbox; end + +# source://thor-1.2.1/lib/thor/shell.rb:23 +module Thor::Shell + # Add shell to initialize config values. + # + # ==== Configuration + # shell<Object>:: An instance of the shell to be used. + # + # ==== Examples + # + # class MyScript < Thor + # argument :first, :type => :numeric + # end + # + # MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new + # + # source://thor-1.2.1/lib/thor/shell.rb:44 + def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def ask(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def error(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def file_collision(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def no?(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def print_in_columns(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def print_table(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def print_wrapped(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def say(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def say_error(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def say_status(*args, &block); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def set_color(*args, &block); end + + # Holds the shell for the given Thor instance. If no shell is given, + # it gets a default shell from Thor::Base.shell. + # + # source://thor-1.2.1/lib/thor/shell.rb:52 + def shell; end + + # Sets the attribute shell + # + # @param value the value to set the attribute shell to. + # + # source://thor-1.2.1/lib/thor/shell.rb:25 + def shell=(_arg0); end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def terminal_width(*args, &block); end + + # Yields the given block with padding. + # + # source://thor-1.2.1/lib/thor/shell.rb:66 + def with_padding; end + + # source://thor-1.2.1/lib/thor/shell.rb:59 + def yes?(*args, &block); end + + protected + + # Allow shell to be shared between invocations. + # + # source://thor-1.2.1/lib/thor/shell.rb:77 + def _shared_configuration; end +end + +# source://thor-1.2.1/lib/thor/shell/basic.rb:3 +class Thor::Shell::Basic + # Initialize base, mute and padding to nil. + # + # @return [Basic] a new instance of Basic + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:11 + def initialize; end + + # Asks something to the user and receives a response. + # + # If a default value is specified it will be presented to the user + # and allows them to select that value with an empty response. This + # option is ignored when limited answers are supplied. + # + # If asked to limit the correct responses, you can pass in an + # array of acceptable answers. If one of those is not supplied, + # they will be shown a message stating that one of those answers + # must be given and re-asked the question. + # + # If asking for sensitive information, the :echo option can be set + # to false to mask user input from $stdin. + # + # If the required input is a path, then set the path option to + # true. This will enable tab completion for file paths relative + # to the current working directory on systems that support + # Readline. + # + # ==== Example + # ask("What is your name?") + # + # ask("What is the planet furthest from the sun?", :default => "Pluto") + # + # ask("What is your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"]) + # + # ask("What is your password?", :echo => false) + # + # ask("Where should the file be saved?", :path => true) + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:78 + def ask(statement, *args); end + + # Returns the value of attribute base. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:6 + def base; end + + # Sets the attribute base + # + # @param value the value to set the attribute base to. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:6 + def base=(_arg0); end + + # Called if something goes wrong during the execution. This is used by Thor + # internally and should not be used inside your scripts. If something went + # wrong, you can always raise an exception. If you raise a Thor::Error, it + # will be rescued and wrapped in the method below. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:342 + def error(statement); end + + # Deals with file collision and returns true if the file should be + # overwritten and false otherwise. If a block is given, it uses the block + # response as the content for the diff. + # + # ==== Parameters + # destination<String>:: the destination file to solve conflicts + # block<Proc>:: an optional block that returns the value to be used in diff and merge + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:285 + def file_collision(destination); end + + # Sets the output padding while executing a block and resets it. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:41 + def indent(count = T.unsafe(nil)); end + + # Mute everything that's inside given block + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:20 + def mute; end + + # Check if base is muted + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:29 + def mute?; end + + # Make a question the to user and returns true if the user replies "n" or + # "no". + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:154 + def no?(statement, color = T.unsafe(nil)); end + + # Returns the value of attribute padding. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:7 + def padding; end + + # Sets the output padding, not allowing less than zero values. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:35 + def padding=(value); end + + # Prints values in columns + # + # ==== Parameters + # Array[String, String, ...] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:163 + def print_in_columns(array); end + + # Prints a table. + # + # ==== Parameters + # Array[Array[String, String, ...]] + # + # ==== Options + # indent<Integer>:: Indent the first column by indent value. + # colwidth<Integer>:: Force the first column to colwidth spaces wide. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:185 + def print_table(array, options = T.unsafe(nil)); end + + # Prints a long string, word-wrapping the text to the current width of the + # terminal display. Ideal for printing heredocs. + # + # ==== Parameters + # String + # + # ==== Options + # indent<Integer>:: Indent each line of the printed paragraph by indent value. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:247 + def print_wrapped(message, options = T.unsafe(nil)); end + + # Say (print) something to the user. If the sentence ends with a whitespace + # or tab character, a new line is not appended (print + flush). Otherwise + # are passed straight to puts (behavior got from Highline). + # + # ==== Example + # say("I know you knew that.") + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:96 + def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end + + # Say (print) an error to the user. If the sentence ends with a whitespace + # or tab character, a new line is not appended (print + flush). Otherwise + # are passed straight to puts (behavior got from Highline). + # + # ==== Example + # say_error("error: something went wrong") + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:113 + def say_error(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end + + # Say a status with the given color and appends the message. Since this + # method is used frequently by actions, it allows nil or false to be given + # in log_status, avoiding the message from being shown. If a Symbol is + # given in log_status, it's used as the color. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:128 + def say_status(status, message, log_status = T.unsafe(nil)); end + + # Apply color to the given string with optional bold. Disabled in the + # Thor::Shell::Basic class. + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:349 + def set_color(string, *_arg1); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:326 + def terminal_width; end + + # Make a question the to user and returns true if the user replies "y" or + # "yes". + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:147 + def yes?(statement, color = T.unsafe(nil)); end + + protected + + # source://thor-1.2.1/lib/thor/shell/basic.rb:486 + def answer_match(possibilities, answer, case_insensitive); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:443 + def as_unicode; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:473 + def ask_filtered(statement, color, options); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:456 + def ask_simply(statement, color, options); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:360 + def can_display_colors?; end + + # Calculate the dynamic width of the terminal + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:415 + def dynamic_width; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:419 + def dynamic_width_stty; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:423 + def dynamic_width_tput; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:387 + def file_collision_help; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:507 + def git_merge_tool; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:377 + def is?(value); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:364 + def lookup_color(color); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:494 + def merge(destination, content); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:503 + def merge_tool; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:355 + def prepare_message(message, *color); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:410 + def quiet?; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:399 + def show_diff(destination, content); end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:373 + def stderr; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:369 + def stdout; end + + # source://thor-1.2.1/lib/thor/shell/basic.rb:431 + def truncate(string, width); end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/basic.rb:427 + def unix?; end +end + +# source://thor-1.2.1/lib/thor/shell/basic.rb:4 +Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) + +# Inherit from Thor::Shell::Basic and add set_color behavior. Check +# Thor::Shell::Basic to see all available methods. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:9 +class Thor::Shell::Color < ::Thor::Shell::Basic + # Set color by using a string or one of the defined constants. If a third + # option is set to true, it also adds bold to the string. This is based + # on Highline implementation and it automatically appends CLEAR to the end + # of the returned String. + # + # Pass foreground, background and bold options to this method as + # symbols. + # + # Example: + # + # set_color "Hi!", :red, :on_white, :bold + # + # The available colors are: + # + # :bold + # :black + # :red + # :green + # :yellow + # :blue + # :magenta + # :cyan + # :white + # :on_black + # :on_red + # :on_green + # :on_yellow + # :on_blue + # :on_magenta + # :on_cyan + # :on_white + # + # source://thor-1.2.1/lib/thor/shell/color.rb:79 + def set_color(string, *colors); end + + protected + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/color.rb:107 + def are_colors_disabled?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/color.rb:103 + def are_colors_supported?; end + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/color.rb:99 + def can_display_colors?; end + + # Check if Diff::LCS is loaded. If it is, use it to create pretty output + # for diff. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/color.rb:144 + def diff_lcs_loaded?; end + + # source://thor-1.2.1/lib/thor/shell/color.rb:127 + def output_diff_line(diff); end + + # Overwrite show_diff to show diff with colors if Diff::LCS is + # available. + # + # source://thor-1.2.1/lib/thor/shell/color.rb:114 + def show_diff(destination, content); end +end + +# Set the terminal's foreground ANSI color to black. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:15 +Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to blue. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:23 +Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String) + +# The start of an ANSI bold sequence. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:12 +Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String) + +# Embed in a String to clear all previous ANSI sequences. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:10 +Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to cyan. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:27 +Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to green. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:19 +Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to magenta. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:25 +Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to black. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:32 +Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to blue. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:40 +Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to cyan. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:44 +Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to green. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:36 +Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to magenta. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:42 +Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to red. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:34 +Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to white. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:46 +Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String) + +# Set the terminal's background ANSI color to yellow. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:38 +Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to red. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:17 +Thor::Shell::Color::RED = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to white. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:29 +Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground ANSI color to yellow. +# +# source://thor-1.2.1/lib/thor/shell/color.rb:21 +Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String) + +# Inherit from Thor::Shell::Basic and add set_color behavior. Check +# Thor::Shell::Basic to see all available methods. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:9 +class Thor::Shell::HTML < ::Thor::Shell::Basic + # Ask something to the user and receives a response. + # + # ==== Example + # ask("What is your name?") + # + # TODO: Implement #ask for Thor::Shell::HTML + # + # @raise [NotImplementedError] + # + # source://thor-1.2.1/lib/thor/shell/html.rb:70 + def ask(statement, color = T.unsafe(nil)); end + + # Set color by using a string or one of the defined constants. If a third + # option is set to true, it also adds bold to the string. This is based + # on Highline implementation and it automatically appends CLEAR to the end + # of the returned String. + # + # source://thor-1.2.1/lib/thor/shell/html.rb:51 + def set_color(string, *colors); end + + protected + + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/html.rb:76 + def can_display_colors?; end + + # Check if Diff::LCS is loaded. If it is, use it to create pretty output + # for diff. + # + # @return [Boolean] + # + # source://thor-1.2.1/lib/thor/shell/html.rb:113 + def diff_lcs_loaded?; end + + # source://thor-1.2.1/lib/thor/shell/html.rb:96 + def output_diff_line(diff); end + + # Overwrite show_diff to show diff with colors if Diff::LCS is + # available. + # + # source://thor-1.2.1/lib/thor/shell/html.rb:83 + def show_diff(destination, content); end +end + +# Set the terminal's foreground HTML color to black. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:13 +Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to blue. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:21 +Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String) + +# The start of an HTML bold sequence. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:10 +Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to cyan. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:25 +Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to green. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:17 +Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to magenta. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:23 +Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to black. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:30 +Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to blue. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:38 +Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to cyan. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:42 +Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to green. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:34 +Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to magenta. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:40 +Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to red. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:32 +Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to white. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:44 +Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String) + +# Set the terminal's background HTML color to yellow. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:36 +Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to red. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:15 +Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to white. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:27 +Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String) + +# Set the terminal's foreground HTML color to yellow. +# +# source://thor-1.2.1/lib/thor/shell/html.rb:19 +Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String) + +# source://thor-1.2.1/lib/thor/shell.rb:24 +Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array) + +# source://thor-1.2.1/lib/thor/base.rb:23 +Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String) + +# Thor methods that should not be overwritten by the user. +# +# source://thor-1.2.1/lib/thor/base.rb:20 +Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array) + +# source://thor-1.2.1/lib/thor/command.rb:117 +Thor::Task = Thor::Command + +# Raised when a command was not found. +# +# source://thor-1.2.1/lib/thor/error.rb:27 +class Thor::UndefinedCommandError < ::Thor::Error + include ::DidYouMean::Correctable + + # @return [UndefinedCommandError] a new instance of UndefinedCommandError + # + # source://thor-1.2.1/lib/thor/error.rb:46 + def initialize(command, all_commands, namespace); end + + # Returns the value of attribute all_commands. + # + # source://thor-1.2.1/lib/thor/error.rb:44 + def all_commands; end + + # Returns the value of attribute command. + # + # source://thor-1.2.1/lib/thor/error.rb:44 + def command; end +end + +# source://thor-1.2.1/lib/thor/error.rb:28 +class Thor::UndefinedCommandError::SpellChecker + # @return [SpellChecker] a new instance of SpellChecker + # + # source://thor-1.2.1/lib/thor/error.rb:31 + def initialize(error); end + + # source://thor-1.2.1/lib/thor/error.rb:35 + def corrections; end + + # Returns the value of attribute error. + # + # source://thor-1.2.1/lib/thor/error.rb:29 + def error; end + + # source://thor-1.2.1/lib/thor/error.rb:39 + def spell_checker; end +end + +# source://thor-1.2.1/lib/thor/error.rb:58 +Thor::UndefinedTaskError = Thor::UndefinedCommandError + +# source://thor-1.2.1/lib/thor/error.rb:68 +class Thor::UnknownArgumentError < ::Thor::Error + include ::DidYouMean::Correctable + + # @return [UnknownArgumentError] a new instance of UnknownArgumentError + # + # source://thor-1.2.1/lib/thor/error.rb:88 + def initialize(switches, unknown); end + + # Returns the value of attribute switches. + # + # source://thor-1.2.1/lib/thor/error.rb:86 + def switches; end + + # Returns the value of attribute unknown. + # + # source://thor-1.2.1/lib/thor/error.rb:86 + def unknown; end +end + +# source://thor-1.2.1/lib/thor/error.rb:69 +class Thor::UnknownArgumentError::SpellChecker + # @return [SpellChecker] a new instance of SpellChecker + # + # source://thor-1.2.1/lib/thor/error.rb:72 + def initialize(error); end + + # source://thor-1.2.1/lib/thor/error.rb:76 + def corrections; end + + # Returns the value of attribute error. + # + # source://thor-1.2.1/lib/thor/error.rb:70 + def error; end + + # source://thor-1.2.1/lib/thor/error.rb:81 + def spell_checker; end +end + +# This module holds several utilities: +# +# 1) Methods to convert thor namespaces to constants and vice-versa. +# +# Thor::Util.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz" +# +# 2) Loading thor files and sandboxing: +# +# Thor::Util.load_thorfile("~/.thor/foo") +# +# source://thor-1.2.1/lib/thor/util.rb:17 +module Thor::Util + class << self + # Receives a string and convert it to camel case. camel_case returns CamelCase. + # + # ==== Parameters + # String + # + # ==== Returns + # String + # + # source://thor-1.2.1/lib/thor/util.rb:104 + def camel_case(str); end + + # Returns a string that has had any glob characters escaped. + # The glob characters are `* ? { } [ ]`. + # + # ==== Examples + # + # Thor::Util.escape_globs('[apps]') # => '\[apps\]' + # + # ==== Parameters + # String + # + # ==== Returns + # String + # + # source://thor-1.2.1/lib/thor/util.rb:263 + def escape_globs(path); end + + # Returns a string that has had any HTML characters escaped. + # + # ==== Examples + # + # Thor::Util.escape_html('<div>') # => "<div>" + # + # ==== Parameters + # String + # + # ==== Returns + # String + # + # source://thor-1.2.1/lib/thor/util.rb:279 + def escape_html(string); end + + # Receives a namespace and search for it in the Thor::Base subclasses. + # + # ==== Parameters + # namespace<String>:: The namespace to search for. + # + # source://thor-1.2.1/lib/thor/util.rb:24 + def find_by_namespace(namespace); end + + # Receives a namespace and tries to retrieve a Thor or Thor::Group class + # from it. It first searches for a class using the all the given namespace, + # if it's not found, removes the highest entry and searches for the class + # again. If found, returns the highest entry as the class name. + # + # ==== Examples + # + # class Foo::Bar < Thor + # def baz + # end + # end + # + # class Baz::Foo < Thor::Group + # end + # + # Thor::Util.namespace_to_thor_class("foo:bar") #=> Foo::Bar, nil # will invoke default command + # Thor::Util.namespace_to_thor_class("baz:foo") #=> Baz::Foo, nil + # Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz" + # + # ==== Parameters + # namespace<String> + # + # source://thor-1.2.1/lib/thor/util.rb:131 + def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end + + # Receives a namespace and tries to retrieve a Thor or Thor::Group class + # from it. It first searches for a class using the all the given namespace, + # if it's not found, removes the highest entry and searches for the class + # again. If found, returns the highest entry as the class name. + # + # ==== Examples + # + # class Foo::Bar < Thor + # def baz + # end + # end + # + # class Baz::Foo < Thor::Group + # end + # + # Thor::Util.namespace_to_thor_class("foo:bar") #=> Foo::Bar, nil # will invoke default command + # Thor::Util.namespace_to_thor_class("baz:foo") #=> Baz::Foo, nil + # Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz" + # + # ==== Parameters + # namespace<String> + # + # source://thor-1.2.1/lib/thor/util.rb:131 + def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end + + # Where to look for Thor files. + # + # source://thor-1.2.1/lib/thor/util.rb:212 + def globs_for(path); end + + # Receives a path and load the thor file in the path. The file is evaluated + # inside the sandbox to avoid namespacing conflicts. + # + # source://thor-1.2.1/lib/thor/util.rb:152 + def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end + + # Receives a constant and converts it to a Thor namespace. Since Thor + # commands can be added to a sandbox, this method is also responsible for + # removing the sandbox namespace. + # + # This method should not be used in general because it's used to deal with + # older versions of Thor. On current versions, if you need to get the + # namespace from a class, just call namespace on it. + # + # ==== Parameters + # constant<Object>:: The constant to be converted to the thor path. + # + # ==== Returns + # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz" + # + # source://thor-1.2.1/lib/thor/util.rb:43 + def namespace_from_thor_class(constant); end + + # Given the contents, evaluate it inside the sandbox and returns the + # namespaces defined in the sandbox. + # + # ==== Parameters + # contents<String> + # + # ==== Returns + # Array[Object] + # + # source://thor-1.2.1/lib/thor/util.rb:58 + def namespaces_in_content(contents, file = T.unsafe(nil)); end + + # Return the path to the ruby interpreter taking into account multiple + # installations and windows extensions. + # + # source://thor-1.2.1/lib/thor/util.rb:220 + def ruby_command; end + + # Receives a string and convert it to snake case. SnakeCase returns snake_case. + # + # ==== Parameters + # String + # + # ==== Returns + # String + # + # source://thor-1.2.1/lib/thor/util.rb:90 + def snake_case(str); end + + # Returns the thor classes declared inside the given class. + # + # source://thor-1.2.1/lib/thor/util.rb:74 + def thor_classes_in(klass); end + + # Returns the root where thor files are located, depending on the OS. + # + # source://thor-1.2.1/lib/thor/util.rb:191 + def thor_root; end + + # Returns the files in the thor root. On Windows thor_root will be something + # like this: + # + # C:\Documents and Settings\james\.thor + # + # If we don't #gsub the \ character, Dir.glob will fail. + # + # source://thor-1.2.1/lib/thor/util.rb:202 + def thor_root_glob; end + + # source://thor-1.2.1/lib/thor/util.rb:167 + def user_home; end + end +end diff --git a/sorbet/rbi/gems/unicode-display_width.rbi b/sorbet/rbi/gems/unicode-display_width.rbi deleted file mode 100644 index 639e97e1..00000000 --- a/sorbet/rbi/gems/unicode-display_width.rbi +++ /dev/null @@ -1,20 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: strict -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/unicode-display_width/all/unicode-display_width.rbi -# -# unicode-display_width-2.2.0 - -module Unicode -end -class Unicode::DisplayWidth - def get_config(**kwargs); end - def initialize(ambiguous: nil, overwrite: nil, emoji: nil); end - def of(string, **kwargs); end - def self.emoji_extra_width_of(string, ambiguous = nil, overwrite = nil, _ = nil); end - def self.of(string, ambiguous = nil, overwrite = nil, options = nil); end -end diff --git a/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi b/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi new file mode 100644 index 00000000..b428bf8f --- /dev/null +++ b/sorbet/rbi/gems/unicode-display_width@2.2.0.rbi @@ -0,0 +1,48 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `unicode-display_width` gem. +# Please instead update this file by running `bin/tapioca gem unicode-display_width`. + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:3 +module Unicode; end + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:4 +class Unicode::DisplayWidth + # @return [DisplayWidth] a new instance of DisplayWidth + # + # source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:46 + def initialize(ambiguous: T.unsafe(nil), overwrite: T.unsafe(nil), emoji: T.unsafe(nil)); end + + # source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:52 + def get_config(**kwargs); end + + # source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:60 + def of(string, **kwargs); end + + class << self + # source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:28 + def emoji_extra_width_of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), _ = T.unsafe(nil)); end + + # source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:10 + def of(string, ambiguous = T.unsafe(nil), overwrite = T.unsafe(nil), options = T.unsafe(nil)); end + end +end + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:7 +Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String) + +# source://unicode-display_width-2.2.0/lib/unicode/display_width.rb:8 +Unicode::DisplayWidth::DEPTHS = T.let(T.unsafe(nil), Array) + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/index.rb:11 +Unicode::DisplayWidth::INDEX = T.let(T.unsafe(nil), Array) + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:8 +Unicode::DisplayWidth::INDEX_FILENAME = T.let(T.unsafe(nil), String) + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:6 +Unicode::DisplayWidth::UNICODE_VERSION = T.let(T.unsafe(nil), String) + +# source://unicode-display_width-2.2.0/lib/unicode/display_width/constants.rb:5 +Unicode::DisplayWidth::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/unparser@0.6.5.rbi b/sorbet/rbi/gems/unparser@0.6.5.rbi new file mode 100644 index 00000000..26e00a92 --- /dev/null +++ b/sorbet/rbi/gems/unparser@0.6.5.rbi @@ -0,0 +1,4529 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `unparser` gem. +# Please instead update this file by running `bin/tapioca gem unparser`. + +# Library namespace +# +# source://unparser-0.6.5/lib/unparser/equalizer.rb:3 +module Unparser + class << self + # Construct a parser buffer from string + # + # @param source [String] + # @return [Parser::Source::Buffer] + # + # source://unparser-0.6.5/lib/unparser.rb:147 + def buffer(source, identification = T.unsafe(nil)); end + + # Parse string into AST + # + # @param source [String] + # @return [Parser::AST::Node, nil] + # + # source://unparser-0.6.5/lib/unparser.rb:105 + def parse(source); end + + # Parse string into either syntax error or AST + # + # @param source [String] + # @return [Either<Parser::SyntaxError, (Parser::ASTNode, nil)>] + # + # source://unparser-0.6.5/lib/unparser.rb:114 + def parse_either(source); end + + # Parse string into AST, with comments + # + # @param source [String] + # @return [Parser::AST::Node] + # + # source://unparser-0.6.5/lib/unparser.rb:125 + def parse_with_comments(source); end + + # Parser instance that produces AST unparser understands + # + # @api private + # @return [Parser::Base] + # + # source://unparser-0.6.5/lib/unparser.rb:134 + def parser; end + + # Unparse an AST (and, optionally, comments) into a string + # + # @api public + # @param node [Parser::AST::Node, nil] + # @param comment_array [Array] + # @raise InvalidNodeError + # if the node passed is invalid + # @return [String] + # + # source://unparser-0.6.5/lib/unparser.rb:60 + def unparse(node, comment_array = T.unsafe(nil)); end + + # Unparse capturing errors + # + # This is mostly useful for writing testing tools against unparser. + # + # @param node [Parser::AST::Node, nil] + # @return [Either<Exception, String>] + # + # source://unparser-0.6.5/lib/unparser.rb:96 + def unparse_either(node); end + + # Unparse with validation + # + # @param node [Parser::AST::Node, nil] + # @param comment_array [Array] + # @return [Either<Validation,String>] + # + # source://unparser-0.6.5/lib/unparser.rb:78 + def unparse_validate(node, comment_array = T.unsafe(nil)); end + end +end + +# Namespace for AST processing tools +# +# source://unparser-0.6.5/lib/unparser/ast.rb:5 +module Unparser::AST + class << self + # Return local variables that get assigned in scope + # + # @api private + # @param node [Parser::AST::Node] + # @return [Set<Symbol>] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:57 + def local_variable_assignments(node); end + + # Return local variables read + # + # @api private + # @param node [Parser::AST::Node] + # @return [Set<Symbol>] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:72 + def local_variable_reads(node); end + + # Test for local variable inherited scope reset + # + # @api private + # @param node [Parser::AST::Node] + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:33 + def not_close_scope?(node); end + + # Test for local variable scope reset + # + # @api private + # @param node [Parser::AST::Node] + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:45 + def not_reset_scope?(node); end + end +end + +# Nodes that assign a local variable +# +# source://unparser-0.6.5/lib/unparser/ast.rb:14 +Unparser::AST::ASSIGN_NODES = T.let(T.unsafe(nil), Set) + +# source://unparser-0.6.5/lib/unparser/ast.rb:11 +Unparser::AST::CLOSE_NODES = T.let(T.unsafe(nil), Array) + +# AST enumerator +# +# source://unparser-0.6.5/lib/unparser/ast.rb:80 +class Unparser::AST::Enumerator + include ::Enumerable + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Return each node + # + # @api private + # @return [Enumerator<Parser::AST::Node>] if no block given + # @return [self] otherwise + # + # source://unparser-0.6.5/lib/unparser/ast.rb:106 + def each(&block); end + + # Return nodes selected by type + # + # @api private + # @param type [Symbol] + # @return [Enumerable<Parser::AST::Node>] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:130 + def type(type); end + + # Return nodes selected by types + # + # @api private + # @param types [Enumerable<Symbol>] + # @return [Enumerable<Parser::AST::Node>] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:118 + def types(types); end + + class << self + # Return new instance + # + # @api private + # @param node [Parser::AST::Node] + # @param controller [#call(node)] + # @return [Enumerator] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:92 + def new(node, controller = T.unsafe(nil)); end + + private + + # Return frozne set of objects + # + # @api private + # @param enumerable [Enumerable] + # @return [Set] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:142 + def set(enumerable); end + + # Return nodes of type + # + # @api private + # @param node [Parser::AST::Node] + # @param type [Symbol] + # @return [Enumerable<Parser::AST::Node]] Enumerable<Parser::AST::Node] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:156 + def type(node, type); end + end +end + +# source://unparser-0.6.5/lib/unparser/ast.rb:6 +Unparser::AST::FIRST_CHILD = T.let(T.unsafe(nil), Proc) + +# source://unparser-0.6.5/lib/unparser/ast.rb:10 +Unparser::AST::INHERIT_NODES = T.let(T.unsafe(nil), Array) + +# Calculated local variable scope for a given node +# +# source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:7 +class Unparser::AST::LocalVariableScope + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Enumerable + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Initialize object + # + # @api private + # @param node [Parser::AST::Node] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:18 + def initialize(node); end + + # Test if local variable was first at given assignment + # + # @api private + # @param node [Parser::AST::Node] + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:35 + def first_assignment?(node); end + + # Test if local variables where first assigned in body and read by conditional + # + # @api private + # @param body [Parser::AST::Node] + # @param condition [Parser::AST::Node] + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:64 + def first_assignment_in?(left, right); end + + # Test if local variable is defined for given node + # + # @api private + # @param node [Parser::AST::Node] + # @param name [Symbol] + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:51 + def local_variable_defined_for_node?(node, name); end + + private + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:76 + def match(needle); end +end + +# Local variable scope enumerator +# +# source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:85 +class Unparser::AST::LocalVariableScopeEnumerator + include ::Enumerable + + # Initialize object + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:94 + def initialize; end + + # Enumerate local variable scope scope + # + # @api private + # @return [self] if block given + # @return [Enumerator<Array<Symbol>>] ] + # otherwise + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:121 + def each(node, &block); end + + private + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:127 + def current; end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:156 + def define(name); end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:141 + def enter(node); end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:152 + def leave(node); end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:168 + def pop; end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:164 + def push_inherit; end + + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:160 + def push_reset; end + + # @yield [node, current.dup, before] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:131 + def visit(node, &block); end + + class << self + # Enumerate each node with its local variable scope + # + # @api private + # @param node [Parser::AST::Node] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/ast/local_variable_scope.rb:106 + def each(node, &block); end + end +end + +# source://unparser-0.6.5/lib/unparser/ast.rb:9 +Unparser::AST::RESET_NODES = T.let(T.unsafe(nil), Array) + +# source://unparser-0.6.5/lib/unparser/ast.rb:7 +Unparser::AST::TAUTOLOGY = T.let(T.unsafe(nil), Proc) + +# Controlled AST walker walking the AST in deeth first search with pre order +# +# source://unparser-0.6.5/lib/unparser/ast.rb:164 +class Unparser::AST::Walker + include ::Unparser::Equalizer::Methods + + # Call walker with node + # + # @api private + # @param node [Parser::AST::Node] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:188 + def call(node); end + + class << self + # Call ast walker + # + # @api private + # @param node [Parser::AST::Node] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/ast.rb:175 + def call(node, controller = T.unsafe(nil), &block); end + end +end + +# Module to allow class and methods to be abstract +# +# Original code before vendoring and reduction from: https://github.com/dkubb/abstract_type. +# +# source://unparser-0.6.5/lib/unparser/abstract_type.rb:7 +module Unparser::AbstractType + mixes_in_class_methods ::Unparser::AbstractType::AbstractMethodDeclarations + + class << self + private + + # Define the new method on the abstract type + # + # Ensures that the instance cannot be of the abstract type + # and must be a descendant. + # + # @api private + # @param abstract_class [Class] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:35 + def create_new_method(abstract_class); end + + # Hook called when module is included + # + # @api private + # @param descendant [Module] the module or class including AbstractType + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:17 + def included(descendant); end + end +end + +# source://unparser-0.6.5/lib/unparser/abstract_type.rb:47 +module Unparser::AbstractType::AbstractMethodDeclarations + # Create abstract instance methods + # + # @api public + # @example + # class Foo + # include AbstractType + # + # # Create an abstract instance method + # abstract_method :some_method + # end + # @param names [Array<#to_s>] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:64 + def abstract_method(*names); end + + # Create abstract singleton methods + # + # @api private + # @example + # class Foo + # include AbstractType + # + # # Create an abstract instance method + # abstract_singleton_method :some_method + # end + # @param names [Array<#to_s>] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:84 + def abstract_singleton_method(*names); end + + private + + # Create abstract instance method + # + # @api private + # @param name [#to_s] the name of the method to create + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:113 + def create_abstract_instance_method(name); end + + # Create abstract singleton method + # + # @api private + # @param name [#to_s] the name of the method to create + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:99 + def create_abstract_singleton_method(name); end +end + +# Allows objects to be made immutable +# +# Original code before vendoring and reduction from: https://github.com/dkubb/adamantium. +# +# source://unparser-0.6.5/lib/unparser/adamantium.rb:7 +module Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + + mixes_in_class_methods ::Unparser::Adamantium::ModuleMethods + mixes_in_class_methods ::Unparser::Adamantium::ClassMethods + + class << self + private + + # ModuleMethods + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:141 + def included(descendant); end + end +end + +# Methods mixed in to adamantium classes +# +# source://unparser-0.6.5/lib/unparser/adamantium.rb:70 +module Unparser::Adamantium::ClassMethods + # Instantiate a new frozen object + # + # @api public + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:77 + def new(*_arg0); end +end + +# source://unparser-0.6.5/lib/unparser/adamantium.rb:8 +module Unparser::Adamantium::InstanceMethods + # A noop #dup for immutable objects + # + # @api public + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:14 + def dup; end + + # Freeze the object + # + # @api public + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:23 + def freeze; end + + private + + # source://unparser-0.6.5/lib/unparser/adamantium.rb:30 + def memoized_method_cache; end +end + +# Storage for memoized methods +# +# source://unparser-0.6.5/lib/unparser/adamantium.rb:37 +class Unparser::Adamantium::Memory + # Initialize the memory storage for memoized methods + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:44 + def initialize(values); end + + # Fetch the value from memory, or evaluate if it does not exist + # + # @api public + # @param name [Symbol] + # @yieldreturn [Object] the value to memoize + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:58 + def fetch(name); end +end + +# Build the memoized method +# +# source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:6 +class Unparser::Adamantium::MethodBuilder + # Initialize an object to build a memoized method + # + # @api private + # @param descendant [Module] + # @param method_name [Symbol] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:47 + def initialize(descendant, method_name); end + + # Build a new memoized method + # + # @api public + # @example + # method_builder.call # => creates new method + # @return [UnboundMethod] + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:63 + def call; end + + private + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:72 + def assert_arity(arity); end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:83 + def create_memoized_method; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:78 + def remove_original_method; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:97 + def set_method_visibility; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:101 + def visibility; end +end + +# Raised when a block is passed to a memoized method +# +# source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:25 +class Unparser::Adamantium::MethodBuilder::BlockNotAllowedError < ::ArgumentError + # Initialize a block not allowed exception + # + # @api private + # @param descendant [Module] + # @param method [Symbol] + # @return [BlockNotAllowedError] a new instance of BlockNotAllowedError + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:33 + def initialize(descendant, method); end +end + +# Raised when the method arity is invalid +# +# source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:9 +class Unparser::Adamantium::MethodBuilder::InvalidArityError < ::ArgumentError + # Initialize an invalid arity exception + # + # @api private + # @param descendant [Module] + # @param method [Symbol] + # @param arity [Integer] + # @return [InvalidArityError] a new instance of InvalidArityError + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:18 + def initialize(descendant, method, arity); end +end + +# Methods mixed in to adamantium modules +# +# source://unparser-0.6.5/lib/unparser/adamantium.rb:84 +module Unparser::Adamantium::ModuleMethods + # Memoize a list of methods + # + # @api public + # @param methods [Array<#to_s>] a list of methods to memoize + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:94 + def memoize(*methods); end + + # Test if method is memoized + # + # @param name [Symbol] + # @return [Bool] + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:104 + def memoized?(method_name); end + + # Return unmemoized instance method + # + # @api public + # @param name [Symbol] + # @raise [NameError] raised if the method is unknown + # @return [UnboundMethod] the memoized method + # + # source://unparser-0.6.5/lib/unparser/adamantium.rb:119 + def unmemoized_instance_method(method_name); end + + private + + # source://unparser-0.6.5/lib/unparser/adamantium.rb:127 + def memoize_method(method_name); end + + # source://unparser-0.6.5/lib/unparser/adamantium.rb:135 + def memoized_methods; end +end + +# Original code before vendoring and reduction from: https://github.com/mbj/anima. +# +# source://unparser-0.6.5/lib/unparser/anima.rb:5 +class Unparser::Anima < ::Module + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Initialize object + # + # + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:18 + def initialize(*names); end + + # Return new anima with attributes added + # + # @example + # anima = Anima.new(:foo) + # anima.add(:bar) # equals Anima.new(:foo, :bar) + # @return [Anima] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:31 + def add(*names); end + + # Return attribute names + # + # @return [Enumerable<Symbol>] + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def attribute_names(&block); end + + # Return names + # + # @return [AttributeSet] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:11 + def attributes; end + + # Return attributes hash for instance + # + # @param object [Object] + # @return [Hash] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:52 + def attributes_hash(object); end + + # Initialize instance + # + # @param object [Object] + # @param attribute_hash [Hash] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:73 + def initialize_instance(object, attribute_hash); end + + # Return new anima with attributes removed + # + # @example + # anima = Anima.new(:foo, :bar) + # anima.remove(:bar) # equals Anima.new(:foo) + # @return [Anima] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:43 + def remove(*names); end + + private + + # Fail unless keys in +attribute_hash+ matches #attribute_names + # + # @param klass [Class] the class being initialized + # @param attribute_hash [Hash] the attributes to initialize +object+ with + # @raise [Error] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:164 + def assert_known_attributes(klass, attribute_hash); end + + # Infect the instance with anima + # + # @param scope [Class, Module] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:137 + def included(descendant); end + + # Return new instance + # + # @param attributes [Enumerable<Symbol>] + # @return [Anima] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:180 + def new(attributes); end +end + +# An attribute +# +# source://unparser-0.6.5/lib/unparser/anima/attribute.rb:6 +class Unparser::Anima::Attribute + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Initialize attribute + # + # @param name [Symbol] + # @return [Attribute] a new instance of Attribute + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:12 + def initialize(name); end + + # Get attribute value from object + # + # @param object [Object] + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:42 + def get(object); end + + # Return instance variable name + # + # @return [Symbol] + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:25 + def instance_variable_name; end + + # Load attribute + # + # @param object [Object] + # @param attributes [Hash] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:33 + def load(object, attributes); end + + # Return attribute name + # + # @return [Symbol] + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:20 + def name; end + + # Set attribute value in object + # + # @param object [Object] + # @param value [Object] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/anima/attribute.rb:52 + def set(object, value); end +end + +# Abstract base class for anima errors +# +# source://unparser-0.6.5/lib/unparser/anima/error.rb:6 +class Unparser::Anima::Error < ::RuntimeError + # Initialize object + # + # @param klass [Class] the class being initialized + # @param missing [Enumerable<Symbol>] + # @param unknown [Enumerable<Symbol>] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/anima/error.rb:18 + def initialize(klass, missing, unknown); end +end + +# source://unparser-0.6.5/lib/unparser/anima/error.rb:7 +Unparser::Anima::Error::FORMAT = T.let(T.unsafe(nil), String) + +# Static instance methods for anima infected classes +# +# source://unparser-0.6.5/lib/unparser/anima.rb:82 +module Unparser::Anima::InstanceMethods + # Initialize an anima infected object + # + # + # @param attributes [#to_h] a hash that matches anima defined attributes + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:91 + def initialize(attributes); end + + # Return a hash representation of an anima infected object + # + # @api public + # @example + # anima.to_h # => { :foo => : bar } + # @return [Hash] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:104 + def to_h; end + + # Return updated instance + # + # @api public + # @example + # klass = Class.new do + # include Anima.new(:foo, :bar) + # end + # + # foo = klass.new(:foo => 1, :bar => 2) + # updated = foo.with(:foo => 3) + # updated.foo # => 3 + # updated.bar # => 2 + # @param attributes [Hash] + # @return [Anima] + # + # source://unparser-0.6.5/lib/unparser/anima.rb:125 + def with(attributes); end +end + +# Buffer used to emit into +# +# source://unparser-0.6.5/lib/unparser/buffer.rb:6 +class Unparser::Buffer + # Initialize object + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:16 + def initialize; end + + # Append string + # + # @api private + # @param string [String] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:29 + def append(string); end + + # Append a string without an indentation prefix + # + # @api private + # @param string [String] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:45 + def append_without_prefix(string); end + + # Capture the content written to the buffer within the block + # + # @api private + # @return [String] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:116 + def capture_content; end + + # Return content of buffer + # + # @api private + # @return [String] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:106 + def content; end + + # Test for a fresh line + # + # @api private + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:96 + def fresh_line?; end + + # Increase indent + # + # @api private + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:56 + def indent; end + + # Write newline + # + # @api private + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:78 + def nl; end + + # source://unparser-0.6.5/lib/unparser/buffer.rb:83 + def root_indent; end + + # Decrease indent + # + # @api private + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:67 + def unindent; end + + # Write raw fragment to buffer + # + # Does not do indentation logic. + # + # @param fragment [String] + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/buffer.rb:129 + def write(fragment); end + + private + + # source://unparser-0.6.5/lib/unparser/buffer.rb:138 + def prefix; end +end + +# source://unparser-0.6.5/lib/unparser/buffer.rb:136 +Unparser::Buffer::INDENT_SPACE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/buffer.rb:8 +Unparser::Buffer::NL = T.let(T.unsafe(nil), String) + +# Unparser specific AST builder defaulting to modern AST format +# +# source://unparser-0.6.5/lib/unparser.rb:23 +class Unparser::Builder < ::Parser::Builders::Default + # @return [Builder] a new instance of Builder + # + # source://unparser-0.6.5/lib/unparser.rb:26 + def initialize; end +end + +# Unparser CLI implementation +# +# source://unparser-0.6.5/lib/unparser/cli.rb:5 +class Unparser::CLI + # Initialize object + # + # @api private + # @param arguments [Array<String>] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:74 + def initialize(arguments); end + + # Add options + # + # + # @api private + # @param builder [OptionParser] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:102 + def add_options(builder); end + + # Return exit status + # + # @api private + # @return [Integer] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:132 + def exit_status; end + + private + + # source://unparser-0.6.5/lib/unparser/cli.rb:155 + def effective_targets; end + + # source://unparser-0.6.5/lib/unparser/cli.rb:143 + def process_target(target); end + + # source://unparser-0.6.5/lib/unparser/cli.rb:170 + def targets(file_name); end + + class << self + # Run CLI + # + # @api private + # @param arguments [Array<String>] + # @return [Integer] the exit status + # + # source://unparser-0.6.5/lib/unparser/cli.rb:63 + def run(*arguments); end + end +end + +# source://unparser-0.6.5/lib/unparser/cli.rb:8 +Unparser::CLI::EXIT_FAILURE = T.let(T.unsafe(nil), Integer) + +# source://unparser-0.6.5/lib/unparser/cli.rb:7 +Unparser::CLI::EXIT_SUCCESS = T.let(T.unsafe(nil), Integer) + +# source://unparser-0.6.5/lib/unparser/cli.rb:10 +class Unparser::CLI::Target + include ::Unparser::AbstractType + extend ::Unparser::AbstractType::AbstractMethodDeclarations + + class << self + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:36 + def new(*args, &block); end + end +end + +# Path target +# +# source://unparser-0.6.5/lib/unparser/cli.rb:14 +class Unparser::CLI::Target::Path < ::Unparser::CLI::Target + include ::Unparser::Equalizer::Methods + + # Literal for this target + # + # @return [Validation] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:27 + def literal_validation; end + + # Validation for this target + # + # @return [Validation] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:20 + def validation; end +end + +# String target +# +# source://unparser-0.6.5/lib/unparser/cli.rb:33 +class Unparser::CLI::Target::String + include ::Unparser::Equalizer::Methods + + # Literal for this target + # + # @return [Validation] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:46 + def literal_validation; end + + # Validation for this target + # + # @return [Validation] + # + # source://unparser-0.6.5/lib/unparser/cli.rb:39 + def validation; end +end + +# Class to colorize strings +# +# source://unparser-0.6.5/lib/unparser/color.rb:5 +class Unparser::Color + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Format text with color + # + # @param text [String] + # @return [String] + # + # source://unparser-0.6.5/lib/unparser/color.rb:13 + def format(text); end +end + +# source://unparser-0.6.5/lib/unparser/color.rb:36 +Unparser::Color::GREEN = T.let(T.unsafe(nil), Unparser::Color) + +# source://unparser-0.6.5/lib/unparser/color.rb:17 +Unparser::Color::NONE = T.let(T.unsafe(nil), T.untyped) + +# source://unparser-0.6.5/lib/unparser/color.rb:35 +Unparser::Color::RED = T.let(T.unsafe(nil), Unparser::Color) + +# Holds the comments that remain to be emitted +# +# source://unparser-0.6.5/lib/unparser/comments.rb:6 +class Unparser::Comments + # Initialize object + # + # @api private + # @param comments [Array] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:30 + def initialize(comments); end + + # Consume part or all of the node + # + # @api private + # @param node [Parser::AST::Node] + # @param source_part [Symbol] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:44 + def consume(node, source_part = T.unsafe(nil)); end + + # Proxy to singleton + # + # NOTICE: + # Delegating to stateless helpers is a pattern I saw many times in our code. + # Maybe we should make another helper module? include SingletonDelegator.new(:source_range) ? + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:18 + def source_range(*arguments); end + + # Take all remaining comments + # + # @api private + # @return [Array] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:68 + def take_all; end + + # Take comments appear in the source before the specified part of the node + # + # @api private + # @param node [Parser::AST::Node] + # @param source_part [Symbol] + # @return [Array] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:81 + def take_before(node, source_part); end + + # Take end-of-line comments + # + # @api private + # @return [Array] + # + # source://unparser-0.6.5/lib/unparser/comments.rb:55 + def take_eol_comments; end + + private + + # source://unparser-0.6.5/lib/unparser/comments.rb:119 + def take_up_to_line(line); end + + # source://unparser-0.6.5/lib/unparser/comments.rb:114 + def take_while; end + + # source://unparser-0.6.5/lib/unparser/comments.rb:123 + def unshift_documents(comments); end + + class << self + # Return source location part + # + # FIXME: This method should not be needed. It does to much inline signalling. + # + # :reek:ManualDispatch + # + # @api private + # @param node [Parser::AST::Node] + # @param part [Symbol] + # @return [Parser::Source::Range] if present + # @return [nil] otherwise + # + # source://unparser-0.6.5/lib/unparser/comments.rb:107 + def source_range(node, part); end + end +end + +# A mixin to define a composition +# +# Original code before vendoring and reduction from: https://github.com/mbj/concord. +# +# source://unparser-0.6.5/lib/unparser/concord.rb:7 +class Unparser::Concord < ::Module + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Initialize object + # + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:30 + def initialize(*names); end + + # Return names + # + # @api private + # @return [Enumerable<Symbol>] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:19 + def names; end + + private + + # Define equalizer + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:48 + def define_equalizer; end + + # Define initialize method + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:72 + def define_initialize; end + + # Define readers + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:58 + def define_readers; end + + # Return instance variable names + # + # @api private + # @return [String] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:92 + def instance_variable_names; end +end + +# The maximum number of objects the hosting class is composed of +# +# source://unparser-0.6.5/lib/unparser/concord.rb:11 +Unparser::Concord::MAX_NR_OF_OBJECTS = T.let(T.unsafe(nil), Integer) + +# Mixin for public attribute readers +# +# source://unparser-0.6.5/lib/unparser/concord.rb:97 +class Unparser::Concord::Public < ::Unparser::Concord + # Hook called when module is included + # + # @api private + # @param descendant [Class, Module] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/concord.rb:107 + def included(descendant); end +end + +# All unparser constants maybe included in other libraries. +# +# source://unparser-0.6.5/lib/unparser/constants.rb:5 +module Unparser::Constants; end + +# All binary operators of the ruby language +# +# source://unparser-0.6.5/lib/unparser/constants.rb:13 +Unparser::Constants::BINARY_OPERATORS = T.let(T.unsafe(nil), Set) + +# source://unparser-0.6.5/lib/unparser/constants.rb:63 +Unparser::Constants::KEYWORDS = T.let(T.unsafe(nil), Set) + +# source://unparser-0.6.5/lib/unparser/constants.rb:45 +Unparser::Constants::K_ALIAS = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:44 +Unparser::Constants::K_AND = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:23 +Unparser::Constants::K_BEGIN = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:37 +Unparser::Constants::K_BREAK = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:24 +Unparser::Constants::K_CASE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:25 +Unparser::Constants::K_CLASS = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:21 +Unparser::Constants::K_DEF = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:28 +Unparser::Constants::K_DEFINE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:33 +Unparser::Constants::K_DEFINED = T.let(T.unsafe(nil), String) + +# Keywords +# +# source://unparser-0.6.5/lib/unparser/constants.rb:20 +Unparser::Constants::K_DO = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:59 +Unparser::Constants::K_EEND = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:46 +Unparser::Constants::K_ELSE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:47 +Unparser::Constants::K_ELSIF = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:58 +Unparser::Constants::K_ENCODING = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:22 +Unparser::Constants::K_END = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:27 +Unparser::Constants::K_ENSURE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:41 +Unparser::Constants::K_FALSE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:60 +Unparser::Constants::K_FILE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:48 +Unparser::Constants::K_FOR = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:43 +Unparser::Constants::K_IF = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:51 +Unparser::Constants::K_IN = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:29 +Unparser::Constants::K_MODULE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:40 +Unparser::Constants::K_NEXT = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:49 +Unparser::Constants::K_NIL = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:50 +Unparser::Constants::K_NOT = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:52 +Unparser::Constants::K_OR = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:35 +Unparser::Constants::K_POSTEXE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:34 +Unparser::Constants::K_PREEXE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:39 +Unparser::Constants::K_REDO = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:30 +Unparser::Constants::K_RESCUE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:38 +Unparser::Constants::K_RETRY = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:31 +Unparser::Constants::K_RETURN = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:26 +Unparser::Constants::K_SELF = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:36 +Unparser::Constants::K_SUPER = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:61 +Unparser::Constants::K_THEN = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:42 +Unparser::Constants::K_TRUE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:32 +Unparser::Constants::K_UNDEF = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:53 +Unparser::Constants::K_UNLESS = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:56 +Unparser::Constants::K_UNTIL = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:54 +Unparser::Constants::K_WHEN = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:55 +Unparser::Constants::K_WHILE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/constants.rb:57 +Unparser::Constants::K_YIELD = T.let(T.unsafe(nil), String) + +# All unary operators of the ruby language +# +# source://unparser-0.6.5/lib/unparser/constants.rb:8 +Unparser::Constants::UNARY_OPERATORS = T.let(T.unsafe(nil), Set) + +# DSL to help defining emitters +# +# source://unparser-0.6.5/lib/unparser/dsl.rb:5 +module Unparser::DSL + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:32 + def children(*names); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:17 + def define_child(name, index); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:24 + def define_group(name, range); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:9 + def define_remaining_children(names); end +end + +# Class to create diffs from source code +# +# source://unparser-0.6.5/lib/unparser/diff.rb:5 +class Unparser::Diff + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Colorized unified source diff between old and new + # + # @return [String] if there is a diff + # @return [nil] otherwise + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def colorized_diff(&block); end + + # Unified source diff between old and new + # + # @return [String] if there is exactly one diff + # @return [nil] otherwise + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def diff(&block); end + + private + + # source://unparser-0.6.5/lib/unparser/diff.rb:62 + def diffs; end + + # source://unparser-0.6.5/lib/unparser/diff.rb:66 + def hunks; end + + # source://unparser-0.6.5/lib/unparser/diff.rb:81 + def max_length; end + + # source://unparser-0.6.5/lib/unparser/diff.rb:72 + def minimized_hunk; end + + class << self + # Build new object from source strings + # + # @param old [String] + # @param new [String] + # @return [Diff] + # + # source://unparser-0.6.5/lib/unparser/diff.rb:46 + def build(old, new); end + + private + + # source://unparser-0.6.5/lib/unparser/diff.rb:85 + def colorize_line(line); end + + # Break up source into lines + # + # @param source [String] + # @return [Array<String>] + # + # source://unparser-0.6.5/lib/unparser/diff.rb:55 + def lines(source); end + end +end + +# source://unparser-0.6.5/lib/unparser/diff.rb:8 +Unparser::Diff::ADDITION = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/diff.rb:9 +Unparser::Diff::DELETION = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/diff.rb:10 +Unparser::Diff::NEWLINE = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser.rb:34 +Unparser::EMPTY_ARRAY = T.let(T.unsafe(nil), Array) + +# source://unparser-0.6.5/lib/unparser.rb:33 +Unparser::EMPTY_STRING = T.let(T.unsafe(nil), String) + +# RequireBLock +# +# source://unparser-0.6.5/lib/unparser/either.rb:21 +class Unparser::Either + include ::Unparser::RequireBlock + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # Test for left constructor + # + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/either.rb:42 + def left?; end + + # Test for right constructor + # + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/either.rb:49 + def right?; end + + class << self + # Execute block and wrap error in left + # + # @param exception [Class<Exception>] + # @return [Either<Exception, Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:33 + def wrap_error(*exceptions); end + end +end + +# source://unparser-0.6.5/lib/unparser/either.rb:56 +class Unparser::Either::Left < ::Unparser::Either + # Evaluate applicative block + # + # @return [Either::Left<Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:64 + def bind(&block); end + + # Evaluate left side of branch + # + # @param left [#call] + # @param _right [#call] + # + # source://unparser-0.6.5/lib/unparser/either.rb:98 + def either(left, _right); end + + # Evaluate functor block + # + # @return [Either::Left<Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:57 + def fmap(&block); end + + # Unwrap value from left + # + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/either.rb:71 + def from_left; end + + # Unwrap value from right + # + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/either.rb:79 + def from_right; end + + # Map over left value + # + # @return [Either::Right<Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:90 + def lmap; end +end + +# Left +# +# source://unparser-0.6.5/lib/unparser/either.rb:106 +class Unparser::Either::Right < ::Unparser::Either + # Evaluate applicative block + # + # @return [Either<Object>] + # @yield [value] + # + # source://unparser-0.6.5/lib/unparser/either.rb:114 + def bind; end + + # Evaluate right side of branch + # + # @param _left [#call] + # @param right [#call] + # + # source://unparser-0.6.5/lib/unparser/either.rb:148 + def either(_left, right); end + + # Evaluate functor block + # + # @return [Either::Right<Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:107 + def fmap; end + + # Unwrap value from left + # + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/either.rb:122 + def from_left; end + + # Unwrap value from right + # + # @return [Object] + # + # source://unparser-0.6.5/lib/unparser/either.rb:133 + def from_right; end + + # Map over left value + # + # @return [Either::Right<Object>] + # + # source://unparser-0.6.5/lib/unparser/either.rb:140 + def lmap(&block); end +end + +# Emitter base class +# +# source://unparser-0.6.5/lib/unparser/emitter.rb:7 +class Unparser::Emitter + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Constants + include ::Unparser::AbstractType + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::AbstractType::AbstractMethodDeclarations + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # Dispatch node write as statement + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:114 + def dispatch(*_arg0); end + + # source://unparser-0.6.5/lib/unparser/emitter.rb:59 + def emit_mlhs; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + # LocalVariableRoot + # + # source://unparser-0.6.5/lib/unparser/emitter.rb:38 + def node_type; end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + + # Return emitter + # + # + # @api private + # @return [Emitter] + # + # source://unparser-0.6.5/lib/unparser/emitter.rb:70 + def emitter(buffer:, comments:, node:, local_variable_scope:); end + + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:36 + def new(*args, &block); end + + private + + # Register emitter for type + # + # @api private + # @param types [Symbol] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/emitter.rb:50 + def handle(*types); end + end +end + +# Emitter for alias nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/alias.rb:6 +class Unparser::Emitter::Alias < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/alias.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def source; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Arguments emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/args.rb:6 +class Unparser::Emitter::Args < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/args.rb:7 + def emit_block_arguments; end + + # source://unparser-0.6.5/lib/unparser/emitter/args.rb:15 + def emit_def_arguments; end + + # source://unparser-0.6.5/lib/unparser/emitter/args.rb:19 + def emit_lambda_arguments; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/args.rb:26 + def emit_shadowargs; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def normal_arguments(&block); end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def shadowargs(&block); end +end + +# Argument emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:82 +class Unparser::Emitter::Argument < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:89 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Array literal emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/array.rb:6 +class Unparser::Emitter::Array < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/array.rb:9 + def emit_heredoc_reminders; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/array.rb:15 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def emitters(&block); end +end + +# Emitter for array patterns +# +# source://unparser-0.6.5/lib/unparser/emitter/array_pattern.rb:6 +class Unparser::Emitter::ArrayPattern < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/array_pattern.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/array_pattern.rb:20 + def emit_member(node); end +end + +# Base class for assignment emitters +# +# source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:7 +class Unparser::Emitter::Assignment < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:14 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:114 + def emit_left(*_arg0); end + + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:10 + def symbol_name; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:22 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:27 + def emit_right; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:8 +Unparser::Emitter::Assignment::BINARY_OPERATOR = T.let(T.unsafe(nil), Array) + +# Constant assignment emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:57 +class Unparser::Emitter::Assignment::Constant < ::Unparser::Emitter::Assignment + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def base; end + + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:65 + def emit_left; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end +end + +# Variable assignment emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:42 +class Unparser::Emitter::Assignment::Variable < ::Unparser::Emitter::Assignment + private + + # source://unparser-0.6.5/lib/unparser/emitter/assignment.rb:50 + def emit_left; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end +end + +# Emitter for begin nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/begin.rb:7 +class Unparser::Emitter::Begin < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/begin.rb:11 + def emit_heredoc_reminders; end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/begin.rb:19 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Non send binary operator / keyword emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/binary.rb:6 +class Unparser::Emitter::Binary < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/binary.rb:11 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def writer(&block); end +end + +# Base class for and and or op-assign +# +# source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:7 +class Unparser::Emitter::BinaryAssign < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:17 + def emit_heredoc_reminders; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:24 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def expression; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:10 +Unparser::Emitter::BinaryAssign::MAP = T.let(T.unsafe(nil), Hash) + +# Block emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/block.rb:7 +class Unparser::Emitter::Block < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def arguments; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:75 + def emit_block_arguments; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:67 + def emit_lambda_arguments; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:61 + def emit_send_target; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:49 + def emit_target; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:24 + def need_do?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:71 + def numblock?; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def target_writer(&block); end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:36 + def write_close; end + + # source://unparser-0.6.5/lib/unparser/emitter/block.rb:28 + def write_open; end +end + +# Block pass node emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:121 +class Unparser::Emitter::BlockPass < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:128 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for toplevel constant reference nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/cbase.rb:6 +class Unparser::Emitter::CBase < ::Unparser::Emitter + private + + # Perform dispatch + # + # @api private + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/emitter/cbase.rb:17 + def dispatch; end +end + +# Emitter for case nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/case.rb:6 +class Unparser::Emitter::Case < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:35 + def emit_condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:22 + def emit_else; end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:30 + def emit_whens; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def whens(&block); end +end + +# Emitter for case guards +# +# source://unparser-0.6.5/lib/unparser/emitter/case_guard.rb:6 +class Unparser::Emitter::CaseGuard < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/case_guard.rb:19 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/case_guard.rb:10 +Unparser::Emitter::CaseGuard::MAP = T.let(T.unsafe(nil), Hash) + +# Emitter for case matches +# +# source://unparser-0.6.5/lib/unparser/emitter/case_match.rb:6 +class Unparser::Emitter::CaseMatch < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/case_match.rb:20 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/case_match.rb:16 + def else_branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/case_match.rb:30 + def emit_else_branch; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def patterns(&block); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Emitter for class nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/class.rb:6 +class Unparser::Emitter::Class < ::Unparser::Emitter + include ::Unparser::Emitter::LocalVariableRoot + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def local_variable_scope(&block); end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/class.rb:15 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/class.rb:23 + def emit_superclass; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def superclass; end +end + +# Emitter for constant access +# +# source://unparser-0.6.5/lib/unparser/emitter/variable.rb:21 +class Unparser::Emitter::Const < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/variable.rb:28 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/variable.rb:33 + def emit_scope; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def scope; end +end + +# Emitter for const pattern node +# +# source://unparser-0.6.5/lib/unparser/emitter/const_pattern.rb:6 +class Unparser::Emitter::ConstPattern < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def const; end + + # source://unparser-0.6.5/lib/unparser/emitter/const_pattern.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def pattern; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Dynamic string emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/dstr.rb:6 +class Unparser::Emitter::DStr < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/dstr.rb:10 + def emit_heredoc_reminders; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/dstr.rb:16 + def dispatch; end +end + +# Dynamic symbol literal emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/dsym.rb:6 +class Unparser::Emitter::DSym < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/dsym.rb:11 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/dsym.rb:34 + def emit_begin_child(component); end + + # source://unparser-0.6.5/lib/unparser/emitter/dsym.rb:24 + def emit_str_child(value); end +end + +# Emitter for def node +# +# source://unparser-0.6.5/lib/unparser/emitter/def.rb:6 +class Unparser::Emitter::Def < ::Unparser::Emitter + include ::Unparser::Emitter::LocalVariableRoot + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def local_variable_scope(&block); end + + private + + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:114 + def body(*_arg0); end + + # source://unparser-0.6.5/lib/unparser/emitter/def.rb:17 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/def.rb:25 + def emit_arguments; end + + # source://unparser-0.6.5/lib/unparser/abstract_type.rb:114 + def emit_name(*_arg0); end +end + +# Instance def emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/def.rb:34 +class Unparser::Emitter::Def::Instance < ::Unparser::Emitter::Def + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def arguments; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/def.rb:41 + def emit_name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for defines on singleton +# +# source://unparser-0.6.5/lib/unparser/emitter/def.rb:48 +class Unparser::Emitter::Def::Singleton < ::Unparser::Emitter::Def + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def arguments; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/def.rb:56 + def emit_name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def subject; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/def.rb:63 + def subject_without_parens?; end +end + +# Emitter for defined? nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/defined.rb:6 +class Unparser::Emitter::Defined < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/defined.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def subject; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/find_pattern.rb:6 +class Unparser::Emitter::FindPattern < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/find_pattern.rb:11 + def dispatch; end +end + +# Emitter for flip flops +# +# source://unparser-0.6.5/lib/unparser/emitter/flipflop.rb:6 +class Unparser::Emitter::FlipFlop < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/flipflop.rb:17 + def symbol_name; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/flipflop.rb:27 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def left; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/flipflop.rb:7 +Unparser::Emitter::FlipFlop::MAP = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/emitter/flipflop.rb:12 +Unparser::Emitter::FlipFlop::SYMBOLS = T.let(T.unsafe(nil), Hash) + +# Emiter for float literals +# +# source://unparser-0.6.5/lib/unparser/emitter/float.rb:6 +class Unparser::Emitter::Float < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/float.rb:16 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/float.rb:11 +Unparser::Emitter::Float::INFINITY = T.let(T.unsafe(nil), Float) + +# source://unparser-0.6.5/lib/unparser/emitter/float.rb:12 +Unparser::Emitter::Float::NEG_INFINITY = T.let(T.unsafe(nil), Float) + +# Emitter control flow modifiers +# +# source://unparser-0.6.5/lib/unparser/emitter/flow_modifier.rb:6 +class Unparser::Emitter::FlowModifier < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/flow_modifier.rb:17 + def emit_heredoc_reminders; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/flow_modifier.rb:25 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/flow_modifier.rb:36 + def emit_arguments; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/flow_modifier.rb:7 +Unparser::Emitter::FlowModifier::MAP = T.let(T.unsafe(nil), Hash) + +# Emitter for for nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/for.rb:6 +class Unparser::Emitter::For < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def assignment; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/for.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/for.rb:20 + def emit_condition; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for Hash literals +# +# source://unparser-0.6.5/lib/unparser/emitter/hash.rb:6 +class Unparser::Emitter::Hash < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/hash.rb:17 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/emitter/hash.rb:9 + def emit_last_argument_hash; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/hash.rb:23 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/hash.rb:39 + def emit_hash_body; end + + # source://unparser-0.6.5/lib/unparser/emitter/hash.rb:35 + def emit_heredoc_reminder_member(node); end +end + +# Emitter for hash patterns +# +# source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:6 +class Unparser::Emitter::HashPattern < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:10 + def emit_const_pattern; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:18 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:24 + def emit_hash_body; end + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:41 + def emit_match_var(node); end + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:28 + def emit_member(node); end + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:46 + def emit_pair(node); end + + # source://unparser-0.6.5/lib/unparser/emitter/hash_pattern.rb:62 + def write_symbol_body(symbol); end +end + +# Base class for pre and postexe emitters +# +# source://unparser-0.6.5/lib/unparser/emitter/hookexe.rb:6 +class Unparser::Emitter::Hookexe < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/hookexe.rb:19 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/hookexe.rb:8 +Unparser::Emitter::Hookexe::MAP = T.let(T.unsafe(nil), Hash) + +# Emitter if nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/if.rb:6 +class Unparser::Emitter::If < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:11 + def emit_ternary; end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:21 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def else_branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:59 + def emit_condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:71 + def emit_else_branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:63 + def emit_if_branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:43 + def emit_normal; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:37 + def emit_postcondition; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def if_branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:55 + def keyword; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:29 + def postcondition?; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/if.rb:51 + def unless?; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/in_match.rb:6 +class Unparser::Emitter::InMatch < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/in_match.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def pattern; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/in_pattern.rb:6 +class Unparser::Emitter::InPattern < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def branch; end + + # source://unparser-0.6.5/lib/unparser/emitter/in_pattern.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def else_branch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def unless_guard; end +end + +# Emitter for send to index references +# +# source://unparser-0.6.5/lib/unparser/emitter/index.rb:6 +class Unparser::Emitter::Index < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:10 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:15 + def emit_receiver; end +end + +# Emitter for assign to index nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/index.rb:34 +class Unparser::Emitter::Index::Assign < ::Unparser::Emitter::Index + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:47 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:43 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:54 + def emit_mlhs; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:61 + def emit_operation(indices); end +end + +# source://unparser-0.6.5/lib/unparser/emitter/index.rb:39 +Unparser::Emitter::Index::Assign::NO_VALUE_PARENT = T.let(T.unsafe(nil), Set) + +# source://unparser-0.6.5/lib/unparser/emitter/index.rb:38 +Unparser::Emitter::Index::Assign::VALUE_RANGE = T.let(T.unsafe(nil), Range) + +# source://unparser-0.6.5/lib/unparser/emitter/index.rb:19 +class Unparser::Emitter::Index::Reference < ::Unparser::Emitter::Index + private + + # source://unparser-0.6.5/lib/unparser/emitter/index.rb:26 + def emit_operation; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def indices(&block); end +end + +# Emitter for explicit begins +# +# source://unparser-0.6.5/lib/unparser/emitter/kwbegin.rb:6 +class Unparser::Emitter::KWBegin < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/kwbegin.rb:11 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/kwbegin.rb:25 + def emit_multiple_body; end +end + +# Optional keyword argument emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:39 +class Unparser::Emitter::KeywordOptional < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:46 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# Emitter for splats +# +# source://unparser-0.6.5/lib/unparser/emitter/splat.rb:6 +class Unparser::Emitter::KwSplat < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/splat.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def subject; end +end + +# Keyword argument emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:54 +class Unparser::Emitter::Kwarg < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:61 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/kwargs.rb:5 +class Unparser::Emitter::Kwargs < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/kwargs.rb:8 + def dispatch; end +end + +# Emitter for lambda nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/lambda.rb:6 +class Unparser::Emitter::Lambda < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/lambda.rb:11 + def dispatch; end +end + +# source://unparser-0.6.5/lib/unparser/emitter.rb:20 +module Unparser::Emitter::LocalVariableRoot + # Return local variable root + # + # @api private + # @return [Parser::AST::Node] + # + # source://unparser-0.6.5/lib/unparser/emitter.rb:27 + def local_variable_scope; end + + class << self + # @private + # + # source://unparser-0.6.5/lib/unparser/emitter.rb:31 + def included(descendant); end + end +end + +# Emitter for multiple assignment nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/masgn.rb:6 +class Unparser::Emitter::MASGN < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/masgn.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def source; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Emitter for multiple assignment left hand side +# +# source://unparser-0.6.5/lib/unparser/emitter/mlhs.rb:6 +class Unparser::Emitter::MLHS < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/mlhs.rb:15 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/mlhs.rb:31 + def emit_many; end + + # source://unparser-0.6.5/lib/unparser/emitter/mlhs.rb:23 + def emit_one_child_mlhs; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/mlhs.rb:9 +Unparser::Emitter::MLHS::NO_COMMA = T.let(T.unsafe(nil), Array) + +# Base class for special match node emitters +# +# source://unparser-0.6.5/lib/unparser/emitter/match.rb:8 +class Unparser::Emitter::Match < ::Unparser::Emitter; end + +# Emitter for match current line +# +# source://unparser-0.6.5/lib/unparser/emitter/match.rb:25 +class Unparser::Emitter::Match::CurrentLine < ::Unparser::Emitter::Match + private + + # source://unparser-0.6.5/lib/unparser/emitter/match.rb:32 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def regexp; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for match with local variable assignment +# +# source://unparser-0.6.5/lib/unparser/emitter/match.rb:9 +class Unparser::Emitter::Match::Lvasgn < ::Unparser::Emitter::Match + private + + # source://unparser-0.6.5/lib/unparser/emitter/match.rb:16 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def lvasgn; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def regexp; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/match_alt.rb:6 +class Unparser::Emitter::MatchAlt < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_alt.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def left; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/match_as.rb:6 +class Unparser::Emitter::MatchAs < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_as.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def left; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/match_pattern.rb:6 +class Unparser::Emitter::MatchPattern < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_pattern.rb:23 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def pattern; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Modern ast format emits `match_pattern` +# node on single line pre 3.0, but 3.0+ uses `match_pattern_p` +# +# source://unparser-0.6.5/lib/unparser/emitter/match_pattern.rb:14 +Unparser::Emitter::MatchPattern::SYMBOL = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/emitter/match_pattern_p.rb:5 +class Unparser::Emitter::MatchPatternP < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_pattern_p.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def pattern; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Emiter for match rest nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/match_rest.rb:6 +class Unparser::Emitter::MatchRest < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/match_rest.rb:11 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/match_rest.rb:16 + def emit_array_pattern; end + + # source://unparser-0.6.5/lib/unparser/emitter/match_rest.rb:21 + def emit_hash_pattern; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_rest.rb:28 + def emit_match_var; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def match_var; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for in pattern nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/match_var.rb:6 +class Unparser::Emitter::MatchVar < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/match_var.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for module nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/module.rb:6 +class Unparser::Emitter::Module < ::Unparser::Emitter + include ::Unparser::Emitter::LocalVariableRoot + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def local_variable_scope(&block); end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/module.rb:15 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for block and kwrestarg arguments +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:6 +class Unparser::Emitter::Morearg < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:18 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:7 +Unparser::Emitter::Morearg::MAP = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/emitter.rb:18 +Unparser::Emitter::NO_INDENT = T.let(T.unsafe(nil), Array) + +# Emitter for nth_ref nodes (regexp captures) +# +# source://unparser-0.6.5/lib/unparser/emitter/variable.rb:42 +class Unparser::Emitter::NthRef < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/variable.rb:50 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/variable.rb:43 +Unparser::Emitter::NthRef::PREFIX = T.let(T.unsafe(nil), String) + +# Emitter for op assign +# +# source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:33 +class Unparser::Emitter::OpAssign < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:40 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/op_assign.rb:46 + def emit_operator; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def operator; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# Optional argument emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:25 +class Unparser::Emitter::Optarg < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:32 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# Emitter for key value pairs in hash literals or kwargs +# +# source://unparser-0.6.5/lib/unparser/emitter/pair.rb:6 +class Unparser::Emitter::Pair < ::Unparser::Emitter + private + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/pair.rb:28 + def colon?(key); end + + # source://unparser-0.6.5/lib/unparser/emitter/pair.rb:17 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def key; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/pair.rb:7 +Unparser::Emitter::Pair::BAREWORD = T.let(T.unsafe(nil), Regexp) + +# Emitter for pin nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/pin.rb:6 +class Unparser::Emitter::Pin < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/pin.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def target; end +end + +# Emitter for postconditions +# +# source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:7 +class Unparser::Emitter::Post < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:19 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:10 +Unparser::Emitter::Post::MAP = T.let(T.unsafe(nil), Hash) + +# Base class for primitive emitters +# +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:6 +class Unparser::Emitter::Primitive < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def value; end +end + +# Emitter for complex literals +# +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:24 +class Unparser::Emitter::Primitive::Complex < ::Unparser::Emitter::Primitive + private + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:39 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:44 + def emit_imaginary; end + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:48 + def imaginary_node; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:30 +Unparser::Emitter::Primitive::Complex::MAP = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:28 +Unparser::Emitter::Primitive::Complex::RATIONAL_FORMAT = T.let(T.unsafe(nil), String) + +# Emitter for primitives based on Object#inspect +# +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:11 +class Unparser::Emitter::Primitive::Inspect < ::Unparser::Emitter::Primitive + private + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:17 + def dispatch; end +end + +# Emiter for numeric literals +# +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:80 +class Unparser::Emitter::Primitive::Numeric < ::Unparser::Emitter::Primitive + private + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:86 + def dispatch; end +end + +# Emitter for rational literals +# +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:56 +class Unparser::Emitter::Primitive::Rational < ::Unparser::Emitter::Primitive + private + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:65 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:73 + def write_rational(value); end +end + +# source://unparser-0.6.5/lib/unparser/emitter/primitive.rb:60 +Unparser::Emitter::Primitive::Rational::RATIONAL_FORMAT = T.let(T.unsafe(nil), String) + +# Progarg emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:96 +class Unparser::Emitter::Procarg < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:103 + def dispatch; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:113 + def needs_parens?; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:99 +Unparser::Emitter::Procarg::PARENS = T.let(T.unsafe(nil), Array) + +# Registry for node emitters +# +# source://unparser-0.6.5/lib/unparser/emitter.rb:16 +Unparser::Emitter::REGISTRY = T.let(T.unsafe(nil), Hash) + +# Range emitters +# +# source://unparser-0.6.5/lib/unparser/emitter/range.rb:6 +class Unparser::Emitter::Range < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/range.rb:17 + def symbol_name; end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def begin_node; end + + # source://unparser-0.6.5/lib/unparser/emitter/range.rb:27 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def end_node; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/range.rb:12 +Unparser::Emitter::Range::SYMBOLS = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/emitter/range.rb:7 +Unparser::Emitter::Range::TOKENS = T.let(T.unsafe(nil), Hash) + +# Emitter for regexp literals +# +# source://unparser-0.6.5/lib/unparser/emitter/regexp.rb:6 +class Unparser::Emitter::Regexp < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def body(&block); end + + # source://unparser-0.6.5/lib/unparser/emitter/regexp.rb:13 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/regexp.rb:24 + def emit_body(node); end + + # source://unparser-0.6.5/lib/unparser/emitter/regexp.rb:20 + def emit_options; end +end + +# Emitter for while and until nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:27 +class Unparser::Emitter::Repetition < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def condition; end + + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:39 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:51 + def emit_keyword; end + + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:55 + def emit_normal; end + + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:66 + def emit_postcontrol; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:47 + def postcontrol?; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/repetition.rb:28 +Unparser::Emitter::Repetition::MAP = T.let(T.unsafe(nil), Hash) + +# Emitter for rescue nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/rescue.rb:6 +class Unparser::Emitter::Rescue < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/rescue.rb:11 + def dispatch; end +end + +# Rest argument emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/argument.rb:68 +class Unparser::Emitter::Restarg < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/argument.rb:75 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Root emitter a special case +# +# source://unparser-0.6.5/lib/unparser/emitter/root.rb:6 +class Unparser::Emitter::Root < ::Unparser::Emitter + include ::Unparser::Emitter::LocalVariableRoot + + # source://unparser-0.6.5/lib/unparser/emitter/root.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def local_variable_scope(&block); end +end + +# source://unparser-0.6.5/lib/unparser/emitter/root.rb:10 +Unparser::Emitter::Root::END_NL = T.let(T.unsafe(nil), Array) + +# Emitter for sclass nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/class.rb:33 +class Unparser::Emitter::SClass < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/emitter/class.rb:40 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def object; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for send +# +# source://unparser-0.6.5/lib/unparser/emitter/send.rb:6 +class Unparser::Emitter::Send < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/send.rb:13 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/emitter/send.rb:9 + def emit_mlhs; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/send.rb:19 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def writer(&block); end +end + +# Emitter for simple nodes that generate a single token +# +# source://unparser-0.6.5/lib/unparser/emitter/simple.rb:6 +class Unparser::Emitter::Simple < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/simple.rb:28 + def dispatch; end +end + +# source://unparser-0.6.5/lib/unparser/emitter/simple.rb:7 +Unparser::Emitter::Simple::MAP = T.let(T.unsafe(nil), Hash) + +# Emitter for splats +# +# source://unparser-0.6.5/lib/unparser/emitter/splat.rb:20 +class Unparser::Emitter::Splat < ::Unparser::Emitter + # source://unparser-0.6.5/lib/unparser/emitter/splat.rb:25 + def emit_mlhs; end + + private + + # source://unparser-0.6.5/lib/unparser/emitter/splat.rb:32 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def subject; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def subject_emitter(&block); end +end + +# Emitter for super nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/super.rb:7 +class Unparser::Emitter::Super < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/super.rb:12 + def dispatch; end +end + +# Emitter for undef nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/undef.rb:6 +class Unparser::Emitter::Undef < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/undef.rb:11 + def dispatch; end +end + +# Emitter for various variable accesses +# +# source://unparser-0.6.5/lib/unparser/emitter/variable.rb:7 +class Unparser::Emitter::Variable < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/variable.rb:14 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def name; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# Emitter for when nodes +# +# source://unparser-0.6.5/lib/unparser/emitter/case.rb:44 +class Unparser::Emitter::When < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def captures(&block); end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:51 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/case.rb:57 + def emit_captures; end +end + +# Dynamic execute string literal emitter +# +# source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:6 +class Unparser::Emitter::XStr < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:12 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:65 + def emit_begin(component); end + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:24 + def emit_heredoc; end + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:51 + def emit_string(value); end + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:39 + def emit_xstr; end + + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:55 + def escape_xstr(input); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/emitter/xstr.rb:20 + def heredoc?; end +end + +# Emitter for yield node +# +# source://unparser-0.6.5/lib/unparser/emitter/yield.rb:7 +class Unparser::Emitter::Yield < ::Unparser::Emitter + private + + # source://unparser-0.6.5/lib/unparser/emitter/yield.rb:12 + def dispatch; end +end + +# Define equality, equivalence and inspection methods +# +# Original code before vendoring and reduction from: https://github.com/dkubb/equalizer. +# +# source://unparser-0.6.5/lib/unparser/equalizer.rb:19 +class Unparser::Equalizer < ::Module + # Initialize an Equalizer with the given keys + # + # Will use the keys with which it is initialized to define #cmp?, + # #hash, and #inspect + # + # + # @api private + # @param keys [Array<Symbol>] + # @return [undefined] + # + # source://unparser-0.6.5/lib/unparser/equalizer.rb:20 + def initialize(*keys); end + + private + + # source://unparser-0.6.5/lib/unparser/equalizer.rb:39 + def define_cmp_method; end + + # source://unparser-0.6.5/lib/unparser/equalizer.rb:49 + def define_hash_method; end + + # source://unparser-0.6.5/lib/unparser/equalizer.rb:56 + def define_inspect_method; end + + # source://unparser-0.6.5/lib/unparser/equalizer.rb:33 + def define_methods; end + + # source://unparser-0.6.5/lib/unparser/equalizer.rb:29 + def included(descendant); end +end + +# The comparison methods +# +# source://unparser-0.6.5/lib/unparser/equalizer.rb:66 +module Unparser::Equalizer::Methods + # Compare the object with other object for equivalency + # + # @api public + # @example + # object == other # => true or false + # @param other [Object] the other object to compare with + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/equalizer.rb:93 + def ==(other); end + + # Compare the object with other object for equality + # + # @api public + # @example + # object.eql?(other) # => true or false + # @param other [Object] the other object to compare with + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/equalizer.rb:78 + def eql?(other); end +end + +# source://unparser-0.6.5/lib/unparser/generation.rb:5 +module Unparser::Generation + # source://unparser-0.6.5/lib/unparser/generation.rb:10 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:12 + def symbol_name; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:14 + def write_to_buffer; end + + private + + # source://unparser-0.6.5/lib/unparser/generation.rb:247 + def children; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:239 + def conditional_parentheses(flag, &block); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:21 + def delimited(nodes, delimiter = T.unsafe(nil), &block); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:123 + def emit_body(node, indent: T.unsafe(nil)); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:196 + def emit_body_ensure_rescue(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:145 + def emit_body_inner(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:158 + def emit_body_member(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:180 + def emit_body_rescue(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:77 + def emit_comments(comments); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:69 + def emit_comments_before(source_part = T.unsafe(nil)); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:166 + def emit_ensure(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:60 + def emit_eof_comments; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:54 + def emit_eol_comments; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:27 + def emit_join(nodes, emit_node, emit_delimiter); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:115 + def emit_optional_body(node, indent: T.unsafe(nil)); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:188 + def emit_optional_body_ensure_rescue(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:206 + def emit_rescue_postcontrol(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:212 + def emit_rescue_regular(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:220 + def emitter(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:235 + def first_child; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:106 + def indented; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:93 + def k_end; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:39 + def nl; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:100 + def parentheses(open = T.unsafe(nil), close = T.unsafe(nil)); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:224 + def visit(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:228 + def visit_deep(node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:44 + def with_comments; end + + # source://unparser-0.6.5/lib/unparser/generation.rb:89 + def write(*strings); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:216 + def writer_with(klass, node); end + + # source://unparser-0.6.5/lib/unparser/generation.rb:50 + def ws; end +end + +# source://unparser-0.6.5/lib/unparser/generation.rb:6 +Unparser::Generation::EXTRA_NL = T.let(T.unsafe(nil), Array) + +# Error raised when unparser encounters an invalid AST +# +# source://unparser-0.6.5/lib/unparser.rb:39 +class Unparser::InvalidNodeError < ::RuntimeError + # @return [InvalidNodeError] a new instance of InvalidNodeError + # + # source://unparser-0.6.5/lib/unparser.rb:42 + def initialize(message, node); end + + # Returns the value of attribute node. + # + # source://unparser-0.6.5/lib/unparser.rb:40 + def node; end +end + +# source://unparser-0.6.5/lib/unparser/node_details.rb:4 +module Unparser::NodeDetails + include ::Unparser::NodeHelpers + include ::Unparser::Constants + + private + + # source://unparser-0.6.5/lib/unparser/node_details.rb:17 + def children; end + + class << self + # @private + # + # source://unparser-0.6.5/lib/unparser/node_details.rb:7 + def included(descendant); end + end +end + +# source://unparser-0.6.5/lib/unparser/node_details/send.rb:5 +class Unparser::NodeDetails::Send + include ::Unparser::NodeHelpers + include ::Unparser::Constants + include ::Unparser::NodeDetails + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def arguments(&block); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:36 + def arguments?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def assignment?(&block); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:32 + def assignment_operator?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:21 + def binary_syntax_allowed?; end + + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:40 + def non_assignment_selector; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def receiver; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def selector; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:17 + def selector_binary_operator?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_details/send.rb:28 + def selector_unary_operator?; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def string_selector(&block); end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end +end + +# source://unparser-0.6.5/lib/unparser/node_details/send.rb:8 +Unparser::NodeDetails::Send::ASSIGN_SUFFIX = T.let(T.unsafe(nil), String) + +# source://unparser-0.6.5/lib/unparser/node_details/send.rb:9 +Unparser::NodeDetails::Send::NON_ASSIGN_RANGE = T.let(T.unsafe(nil), Range) + +# source://unparser-0.6.5/lib/unparser/node_helpers.rb:4 +module Unparser::NodeHelpers + # Helper for building nodes + # + # @api private + # @param type [Symbol] + # @param children [Array] + # @return [Parser::AST::Node] + # + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:26 + def n(type, children = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:30 + def n?(type, node); end + + # Helper for building nodes + # + # @api private + # @param type [Symbol] + # @param children [Parser::AST::Node] + # @return [Parser::AST::Node] + # + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:14 + def s(type, *children); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:71 + def unwrap_single_begin(node); end + + private + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_arg?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_args?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_array?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_array_pattern?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_begin?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_block?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_cbase?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_const?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_dstr?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_empty_else?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_ensure?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_hash?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_hash_pattern?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_if?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_in_pattern?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_int?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_kwarg?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_kwargs?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_kwsplat?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_lambda?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_match_rest?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_pair?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_rescue?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_send?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_shadowarg?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_splat?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_str?(node); end + + # source://unparser-0.6.5/lib/unparser/node_helpers.rb:65 + def n_sym?(node); end +end + +# source://unparser-0.6.5/lib/unparser/either.rb:4 +module Unparser::RequireBlock + private + + # Raise error unless block is provided + # + # @raise [MissingBlockError] if no block is given + # @return [self] + # + # source://unparser-0.6.5/lib/unparser/either.rb:14 + def require_block; end +end + +# source://unparser-0.6.5/lib/unparser/emitter.rb:4 +class Unparser::UnknownNodeError < ::ArgumentError; end + +# Validation of unparser results +# +# source://unparser-0.6.5/lib/unparser/validation.rb:5 +class Unparser::Validation + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def generated_node; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def generated_source; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def identification; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def original_node; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def original_source; end + + # Return error report + # + # @api private + # @return [String] + # + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def report(&block); end + + # Test if source could be unparsed successfully + # + # @api private + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/validation.rb:20 + def success?; end + + private + + # source://unparser-0.6.5/lib/unparser/validation.rb:106 + def make_report(label, attribute_name); end + + # source://unparser-0.6.5/lib/unparser/validation.rb:118 + def node_diff_report; end + + # source://unparser-0.6.5/lib/unparser/validation.rb:110 + def report_exception(exception); end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + + # Create validator from node + # + # @param original_node [Parser::AST::Node] + # @return [Validator] + # + # source://unparser-0.6.5/lib/unparser/validation.rb:79 + def from_node(original_node); end + + # Create validator from file + # + # @param path [Pathname] + # @return [Validator] + # + # source://unparser-0.6.5/lib/unparser/validation.rb:100 + def from_path(path); end + + # Create validator from string + # + # @param original_source [String] + # @return [Validator] + # + # source://unparser-0.6.5/lib/unparser/validation.rb:53 + def from_string(original_source); end + + private + + # source://unparser-0.6.5/lib/unparser/validation.rb:133 + def const_unit(_value); end + end +end + +# source://unparser-0.6.5/lib/unparser/validation.rb:136 +class Unparser::Validation::Literal < ::Unparser::Validation + # source://unparser-0.6.5/lib/unparser/validation.rb:141 + def report; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/validation.rb:137 + def success?; end + + private + + # source://unparser-0.6.5/lib/unparser/validation.rb:156 + def source_diff_report; end +end + +# source://unparser-0.6.5/lib/unparser/writer.rb:4 +module Unparser::Writer + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + + mixes_in_class_methods ::Unparser::DSL + + class << self + # @private + # + # source://unparser-0.6.5/lib/unparser/writer.rb:7 + def included(descendant); end + end +end + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:5 +class Unparser::Writer::Binary + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Writer + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:54 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:46 + def emit_operator; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:50 + def symbol_name; end + + private + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:62 + def effective_symbol; end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:74 + def emit_with(map); end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:80 + def keyword_symbol; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def left; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def left_emitter(&block); end + + # source://unparser-0.6.5/lib/unparser/writer/binary.rb:84 + def operator_symbol; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def right; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def right_emitter(&block); end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + end +end + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:22 +Unparser::Writer::Binary::KEYWORD_SYMBOLS = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:16 +Unparser::Writer::Binary::KEYWORD_TOKENS = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:34 +Unparser::Writer::Binary::MAP = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:42 +Unparser::Writer::Binary::NEED_KEYWORD = T.let(T.unsafe(nil), Array) + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:28 +Unparser::Writer::Binary::OPERATOR_SYMBOLS = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/writer/binary.rb:10 +Unparser::Writer::Binary::OPERATOR_TOKENS = T.let(T.unsafe(nil), Hash) + +# source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:5 +class Unparser::Writer::DynamicString + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Writer + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:32 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:25 + def emit_heredoc_reminder; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + private + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:171 + def breakpoint?(child, current); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:63 + def classify(node); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:71 + def classify_str(node); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:205 + def emit_body(children); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:161 + def emit_dstr; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:144 + def emit_dynamic(child); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:157 + def emit_dynamic_component(node); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:54 + def emit_heredoc_body; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:59 + def emit_heredoc_footer; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:50 + def emit_heredoc_header; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:128 + def emit_normal_heredoc_body; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:197 + def emit_segment(children, index); end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:116 + def emit_squiggly_heredoc_body; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:140 + def escape_dynamic(string); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:46 + def heredoc?; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:42 + def heredoc_header; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:95 + def heredoc_pattern?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:105 + def heredoc_pattern_2?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:99 + def heredoc_pattern_3?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:111 + def nl_last_child?; end + + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:181 + def segments; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:87 + def str_empty?(node); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:83 + def str_nl?(node); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:91 + def str_ws?(node); end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + end +end + +# source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:21 +Unparser::Writer::DynamicString::FLAT_INTERPOLATION = T.let(T.unsafe(nil), Set) + +# source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:8 +Unparser::Writer::DynamicString::PATTERNS_2 = T.let(T.unsafe(nil), Array) + +# source://unparser-0.6.5/lib/unparser/writer/dynamic_string.rb:14 +Unparser::Writer::DynamicString::PATTERNS_3 = T.let(T.unsafe(nil), Array) + +# Writer for rescue bodies +# +# source://unparser-0.6.5/lib/unparser/writer/resbody.rb:6 +class Unparser::Writer::Resbody + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Writer + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # source://unparser-0.6.5/lib/unparser/writer/resbody.rb:11 + def emit_postcontrol; end + + # source://unparser-0.6.5/lib/unparser/writer/resbody.rb:16 + def emit_regular; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def assignment; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/writer/resbody.rb:32 + def emit_assignment; end + + # source://unparser-0.6.5/lib/unparser/writer/resbody.rb:25 + def emit_exception; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def exception; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + end +end + +# source://unparser-0.6.5/lib/unparser/writer/rescue.rb:5 +class Unparser::Writer::Rescue + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Writer + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # source://unparser-0.6.5/lib/unparser/writer/rescue.rb:23 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/writer/rescue.rb:27 + def emit_postcontrol; end + + # source://unparser-0.6.5/lib/unparser/writer/rescue.rb:12 + def emit_regular; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + private + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def body; end + + # source://unparser-0.6.5/lib/unparser/writer/rescue.rb:34 + def else_node; end + + # source://unparser-0.6.5/lib/unparser/writer/rescue.rb:38 + def emit_rescue_body(node); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def rescue_bodies(&block); end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def rescue_body; end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + end +end + +# Writer for send +# +# source://unparser-0.6.5/lib/unparser/writer/send.rb:6 +class Unparser::Writer::Send + include ::Unparser::NodeHelpers + include ::Unparser::Generation + include ::Unparser::Constants + include ::Unparser::Adamantium + include ::Unparser::Adamantium::InstanceMethods + include ::Unparser::Writer + include ::Unparser::Anima::InstanceMethods + include ::Unparser::Equalizer::Methods + extend ::Unparser::Adamantium::ModuleMethods + extend ::Unparser::Adamantium::ClassMethods + extend ::Unparser::DSL + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def buffer; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def comments; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:21 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:33 + def emit_heredoc_reminders; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:25 + def emit_mlhs; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:29 + def emit_selector; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def local_variable_scope; end + + # source://unparser-0.6.5/lib/unparser/anima.rb:146 + def node; end + + private + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:73 + def arguments; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/send.rb:85 + def avoid_clash?; end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def details(&block); end + + # source://unparser-0.6.5/lib/unparser/adamantium/method_builder.rb:87 + def effective_writer(&block); end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:45 + def effective_writer_class; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:65 + def emit_arguments; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:81 + def emit_heredoc_reminder(argument); end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:77 + def emit_normal_arguments; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:61 + def emit_operator; end + + # source://unparser-0.6.5/lib/unparser/writer/send.rb:106 + def emit_send_regular(node); end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/send.rb:89 + def local_variable_clash?; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/send.rb:93 + def parses_as_constant?; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def receiver; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def selector; end + + # @return [Boolean] + # + # source://unparser-0.6.5/lib/unparser/writer/send.rb:57 + def write_as_attribute_assignment?; end + + class << self + # source://unparser-0.6.5/lib/unparser/anima.rb:140 + def anima; end + end +end + +# Writer for send as attribute assignment +# +# source://unparser-0.6.5/lib/unparser/writer/send/attribute_assignment.rb:7 +class Unparser::Writer::Send::AttributeAssignment < ::Unparser::Writer::Send + # source://unparser-0.6.5/lib/unparser/writer/send/attribute_assignment.rb:10 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/writer/send/attribute_assignment.rb:22 + def emit_send_mlhs; end + + private + + # source://unparser-0.6.5/lib/unparser/writer/send/attribute_assignment.rb:34 + def emit_attribute; end + + # source://unparser-0.6.5/lib/unparser/writer/send/attribute_assignment.rb:29 + def emit_receiver; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def first_argument; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def receiver; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:11 + def remaining_children; end + + # source://unparser-0.6.5/lib/unparser/dsl.rb:18 + def selector; end +end + +# Writer for binary sends +# +# source://unparser-0.6.5/lib/unparser/writer/send/binary.rb:7 +class Unparser::Writer::Send::Binary < ::Unparser::Writer::Send + # source://unparser-0.6.5/lib/unparser/writer/send/binary.rb:8 + def dispatch; end + + private + + # source://unparser-0.6.5/lib/unparser/writer/send/binary.rb:16 + def emit_operator; end + + # source://unparser-0.6.5/lib/unparser/writer/send/binary.rb:20 + def emit_right; end +end + +# source://unparser-0.6.5/lib/unparser/writer/send.rb:9 +Unparser::Writer::Send::INDEX_ASSIGN = T.let(T.unsafe(nil), Symbol) + +# source://unparser-0.6.5/lib/unparser/writer/send.rb:10 +Unparser::Writer::Send::INDEX_REFERENCE = T.let(T.unsafe(nil), Symbol) + +# source://unparser-0.6.5/lib/unparser/writer/send.rb:12 +Unparser::Writer::Send::OPERATORS = T.let(T.unsafe(nil), Hash) + +# Writer for "regular" receiver.selector(arguments...) case +# +# source://unparser-0.6.5/lib/unparser/writer/send/regular.rb:7 +class Unparser::Writer::Send::Regular < ::Unparser::Writer::Send + # source://unparser-0.6.5/lib/unparser/writer/send/regular.rb:8 + def dispatch; end + + # source://unparser-0.6.5/lib/unparser/writer/send/regular.rb:18 + def emit_arguments_without_heredoc_body; end + + # source://unparser-0.6.5/lib/unparser/writer/send/regular.rb:22 + def emit_receiver; end + + # source://unparser-0.6.5/lib/unparser/writer/send/regular.rb:14 + def emit_send_mlhs; end +end + +# Writer for unary sends +# +# source://unparser-0.6.5/lib/unparser/writer/send/unary.rb:7 +class Unparser::Writer::Send::Unary < ::Unparser::Writer::Send + # source://unparser-0.6.5/lib/unparser/writer/send/unary.rb:15 + def dispatch; end +end + +# source://unparser-0.6.5/lib/unparser/writer/send/unary.rb:8 +Unparser::Writer::Send::Unary::MAP = T.let(T.unsafe(nil), Hash) diff --git a/sorbet/rbi/gems/webrick@1.7.0.rbi b/sorbet/rbi/gems/webrick@1.7.0.rbi new file mode 100644 index 00000000..65e8a5f9 --- /dev/null +++ b/sorbet/rbi/gems/webrick@1.7.0.rbi @@ -0,0 +1,2586 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `webrick` gem. +# Please instead update this file by running `bin/tapioca gem webrick`. + +# AccessLog provides logging to various files in various formats. +# +# Multiple logs may be written to at the same time: +# +# access_log = [ +# [$stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT], +# [$stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT], +# ] +# +# server = WEBrick::HTTPServer.new :AccessLog => access_log +# +# Custom log formats may be defined. WEBrick::AccessLog provides a subset +# of the formatting from Apache's mod_log_config +# http://httpd.apache.org/docs/mod/mod_log_config.html#formats. See +# AccessLog::setup_params for a list of supported options +# +# source://webrick-1.7.0/lib/webrick/accesslog.rb:30 +module WEBrick::AccessLog + private + + # Escapes control characters in +data+ + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:151 + def escape(data); end + + # Formats +params+ according to +format_string+ which is described in + # setup_params. + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:123 + def format(format_string, params); end + + # This format specification is a subset of mod_log_config of Apache: + # + # %a:: Remote IP address + # %b:: Total response size + # %e{variable}:: Given variable in ENV + # %f:: Response filename + # %h:: Remote host name + # %{header}i:: Given request header + # %l:: Remote logname, always "-" + # %m:: Request method + # %{attr}n:: Given request attribute from <tt>req.attributes</tt> + # %{header}o:: Given response header + # %p:: Server's request port + # %{format}p:: The canonical port of the server serving the request or the + # actual port or the client's actual port. Valid formats are + # canonical, local or remote. + # %q:: Request query string + # %r:: First line of the request + # %s:: Request status + # %t:: Time the request was received + # %T:: Time taken to process the request + # %u:: Remote user from auth + # %U:: Unparsed URI + # %%:: Literal % + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:95 + def setup_params(config, req, res); end + + class << self + # Escapes control characters in +data+ + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:151 + def escape(data); end + + # Formats +params+ according to +format_string+ which is described in + # setup_params. + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:123 + def format(format_string, params); end + + # This format specification is a subset of mod_log_config of Apache: + # + # %a:: Remote IP address + # %b:: Total response size + # %e{variable}:: Given variable in ENV + # %f:: Response filename + # %h:: Remote host name + # %{header}i:: Given request header + # %l:: Remote logname, always "-" + # %m:: Request method + # %{attr}n:: Given request attribute from <tt>req.attributes</tt> + # %{header}o:: Given response header + # %p:: Server's request port + # %{format}p:: The canonical port of the server serving the request or the + # actual port or the client's actual port. Valid formats are + # canonical, local or remote. + # %q:: Request query string + # %r:: First line of the request + # %s:: Request status + # %t:: Time the request was received + # %T:: Time taken to process the request + # %u:: Remote user from auth + # %U:: Unparsed URI + # %%:: Literal % + # + # source://webrick-1.7.0/lib/webrick/accesslog.rb:95 + def setup_params(config, req, res); end + end +end + +# A generic logging class +# +# source://webrick-1.7.0/lib/webrick/log.rb:17 +class WEBrick::BasicLog + # Initializes a new logger for +log_file+ that outputs messages at +level+ + # or higher. +log_file+ can be a filename, an IO-like object that + # responds to #<< or nil which outputs to $stderr. + # + # If no level is given INFO is chosen by default + # + # @return [BasicLog] a new instance of BasicLog + # + # source://webrick-1.7.0/lib/webrick/log.rb:50 + def initialize(log_file = T.unsafe(nil), level = T.unsafe(nil)); end + + # Synonym for log(INFO, obj.to_s) + # + # source://webrick-1.7.0/lib/webrick/log.rb:84 + def <<(obj); end + + # Closes the logger (also closes the log device associated to the logger) + # + # source://webrick-1.7.0/lib/webrick/log.rb:66 + def close; end + + # Shortcut for logging a DEBUG message + # + # source://webrick-1.7.0/lib/webrick/log.rb:97 + def debug(msg); end + + # Will the logger output DEBUG messages? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/log.rb:108 + def debug?; end + + # Shortcut for logging an ERROR message + # + # source://webrick-1.7.0/lib/webrick/log.rb:91 + def error(msg); end + + # Will the logger output ERROR messages? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/log.rb:102 + def error?; end + + # Shortcut for logging a FATAL message + # + # source://webrick-1.7.0/lib/webrick/log.rb:89 + def fatal(msg); end + + # Will the logger output FATAL messages? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/log.rb:100 + def fatal?; end + + # Shortcut for logging an INFO message + # + # source://webrick-1.7.0/lib/webrick/log.rb:95 + def info(msg); end + + # Will the logger output INFO messages? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/log.rb:106 + def info?; end + + # log-level, messages above this level will be logged + # + # source://webrick-1.7.0/lib/webrick/log.rb:41 + def level; end + + # log-level, messages above this level will be logged + # + # source://webrick-1.7.0/lib/webrick/log.rb:41 + def level=(_arg0); end + + # Logs +data+ at +level+ if the given level is above the current log + # level. + # + # source://webrick-1.7.0/lib/webrick/log.rb:75 + def log(level, data); end + + # Shortcut for logging a WARN message + # + # source://webrick-1.7.0/lib/webrick/log.rb:93 + def warn(msg); end + + # Will the logger output WARN messages? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/log.rb:104 + def warn?; end + + private + + # Formats +arg+ for the logger + # + # * If +arg+ is an Exception, it will format the error message and + # the back trace. + # * If +arg+ responds to #to_str, it will return it. + # * Otherwise it will return +arg+.inspect. + # + # source://webrick-1.7.0/lib/webrick/log.rb:119 + def format(arg); end +end + +# Base TCP server class. You must subclass GenericServer and provide a #run +# method. +# +# source://webrick-1.7.0/lib/webrick/server.rb:56 +class WEBrick::GenericServer + # Creates a new generic server from +config+. The default configuration + # comes from +default+. + # + # @return [GenericServer] a new instance of GenericServer + # + # source://webrick-1.7.0/lib/webrick/server.rb:88 + def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end + + # Retrieves +key+ from the configuration + # + # source://webrick-1.7.0/lib/webrick/server.rb:121 + def [](key); end + + # The server configuration + # + # source://webrick-1.7.0/lib/webrick/server.rb:66 + def config; end + + # Adds listeners from +address+ and +port+ to the server. See + # WEBrick::Utils::create_listeners for details. + # + # source://webrick-1.7.0/lib/webrick/server.rb:129 + def listen(address, port); end + + # Sockets listening for connections. + # + # source://webrick-1.7.0/lib/webrick/server.rb:82 + def listeners; end + + # The server logger. This is independent from the HTTP access log. + # + # source://webrick-1.7.0/lib/webrick/server.rb:71 + def logger; end + + # You must subclass GenericServer and implement \#run which accepts a TCP + # client socket + # + # source://webrick-1.7.0/lib/webrick/server.rb:244 + def run(sock); end + + # Shuts down the server and all listening sockets. New listeners must be + # provided to restart the server. + # + # source://webrick-1.7.0/lib/webrick/server.rb:234 + def shutdown; end + + # Starts the server and runs the +block+ for each connection. This method + # does not return until the server is stopped from a signal handler or + # another thread using #stop or #shutdown. + # + # If the block raises a subclass of StandardError the exception is logged + # and ignored. If an IOError or Errno::EBADF exception is raised the + # exception is ignored. If an Exception subclass is raised the exception + # is logged and re-raised which stops the server. + # + # To completely shut down a server call #shutdown from ensure: + # + # server = WEBrick::GenericServer.new + # # or WEBrick::HTTPServer.new + # + # begin + # server.start + # ensure + # server.shutdown + # end + # + # @raise [ServerError] + # + # source://webrick-1.7.0/lib/webrick/server.rb:154 + def start(&block); end + + # The server status. One of :Stop, :Running or :Shutdown + # + # source://webrick-1.7.0/lib/webrick/server.rb:61 + def status; end + + # Stops the server from accepting new connections. + # + # source://webrick-1.7.0/lib/webrick/server.rb:222 + def stop; end + + # Tokens control the number of outstanding clients. The + # <code>:MaxClients</code> configuration sets this. + # + # source://webrick-1.7.0/lib/webrick/server.rb:77 + def tokens; end + + private + + # Accepts a TCP client socket from the TCP server socket +svr+ and returns + # the client socket. + # + # source://webrick-1.7.0/lib/webrick/server.rb:256 + def accept_client(svr); end + + # source://webrick-1.7.0/lib/webrick/server.rb:347 + def alarm_shutdown_pipe; end + + # Calls the callback +callback_name+ from the configuration with +args+ + # + # source://webrick-1.7.0/lib/webrick/server.rb:334 + def call_callback(callback_name, *args); end + + # source://webrick-1.7.0/lib/webrick/server.rb:359 + def cleanup_listener; end + + # source://webrick-1.7.0/lib/webrick/server.rb:342 + def cleanup_shutdown_pipe(shutdown_pipe); end + + # source://webrick-1.7.0/lib/webrick/server.rb:338 + def setup_shutdown_pipe; end + + # Starts a server thread for the client socket +sock+ that runs the given + # +block+. + # + # Sets the socket to the <code>:WEBrickSocket</code> thread local variable + # in the thread. + # + # If any errors occur in the block they are logged and handled. + # + # source://webrick-1.7.0/lib/webrick/server.rb:288 + def start_thread(sock, &block); end +end + +# source://webrick-1.7.0/lib/webrick/htmlutils.rb:13 +module WEBrick::HTMLUtils + private + + # Escapes &, ", > and < in +string+ + # + # source://webrick-1.7.0/lib/webrick/htmlutils.rb:18 + def escape(string); end + + class << self + # Escapes &, ", > and < in +string+ + # + # source://webrick-1.7.0/lib/webrick/htmlutils.rb:18 + def escape(string); end + end +end + +# HTTPAuth provides both basic and digest authentication. +# +# To enable authentication for requests in WEBrick you will need a user +# database and an authenticator. To start, here's an Htpasswd database for +# use with a DigestAuth authenticator: +# +# config = { :Realm => 'DigestAuth example realm' } +# +# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file' +# htpasswd.auth_type = WEBrick::HTTPAuth::DigestAuth +# htpasswd.set_passwd config[:Realm], 'username', 'password' +# htpasswd.flush +# +# The +:Realm+ is used to provide different access to different groups +# across several resources on a server. Typically you'll need only one +# realm for a server. +# +# This database can be used to create an authenticator: +# +# config[:UserDB] = htpasswd +# +# digest_auth = WEBrick::HTTPAuth::DigestAuth.new config +# +# To authenticate a request call #authenticate with a request and response +# object in a servlet: +# +# def do_GET req, res +# @authenticator.authenticate req, res +# end +# +# For digest authentication the authenticator must not be created every +# request, it must be passed in as an option via WEBrick::HTTPServer#mount. +# +# source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:12 +module WEBrick::HTTPAuth + private + + # source://webrick-1.7.0/lib/webrick/httpauth.rb:57 + def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end + + # Simple wrapper for providing basic authentication for a request. When + # called with a request +req+, response +res+, authentication +realm+ and + # +block+ the block will be called with a +username+ and +password+. If + # the block returns true the request is allowed to continue, otherwise an + # HTTPStatus::Unauthorized error is raised. + # + # source://webrick-1.7.0/lib/webrick/httpauth.rb:79 + def basic_auth(req, res, realm, &block); end + + # Simple wrapper for providing basic authentication for a proxied request. + # When called with a request +req+, response +res+, authentication +realm+ + # and +block+ the block will be called with a +username+ and +password+. + # If the block returns true the request is allowed to continue, otherwise + # an HTTPStatus::ProxyAuthenticationRequired error is raised. + # + # source://webrick-1.7.0/lib/webrick/httpauth.rb:91 + def proxy_basic_auth(req, res, realm, &block); end + + class << self + # source://webrick-1.7.0/lib/webrick/httpauth.rb:57 + def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end + + # Simple wrapper for providing basic authentication for a request. When + # called with a request +req+, response +res+, authentication +realm+ and + # +block+ the block will be called with a +username+ and +password+. If + # the block returns true the request is allowed to continue, otherwise an + # HTTPStatus::Unauthorized error is raised. + # + # source://webrick-1.7.0/lib/webrick/httpauth.rb:79 + def basic_auth(req, res, realm, &block); end + + # Simple wrapper for providing basic authentication for a proxied request. + # When called with a request +req+, response +res+, authentication +realm+ + # and +block+ the block will be called with a +username+ and +password+. + # If the block returns true the request is allowed to continue, otherwise + # an HTTPStatus::ProxyAuthenticationRequired error is raised. + # + # source://webrick-1.7.0/lib/webrick/httpauth.rb:91 + def proxy_basic_auth(req, res, realm, &block); end + end +end + +# Module providing generic support for both Digest and Basic +# authentication schemes. +# +# source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:18 +module WEBrick::HTTPAuth::Authenticator + # The logger for this authenticator + # + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:43 + def logger; end + + # The realm this authenticator covers + # + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:33 + def realm; end + + # The user database for this authenticator + # + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:38 + def userdb; end + + private + + # Initializes the authenticator from +config+ + # + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:52 + def check_init(config); end + + # Ensures +req+ has credentials that can be authenticated. + # + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:72 + def check_scheme(req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:91 + def error(fmt, *args); end + + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:97 + def info(fmt, *args); end + + # source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:85 + def log(meth, fmt, *args); end +end + +# source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:23 +WEBrick::HTTPAuth::Authenticator::AuthException = WEBrick::HTTPStatus::Unauthorized + +# Basic Authentication for WEBrick +# +# Use this class to add basic authentication to a WEBrick servlet. +# +# Here is an example of how to set up a BasicAuth: +# +# config = { :Realm => 'BasicAuth example realm' } +# +# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file', password_hash: :bcrypt +# htpasswd.set_passwd config[:Realm], 'username', 'password' +# htpasswd.flush +# +# config[:UserDB] = htpasswd +# +# basic_auth = WEBrick::HTTPAuth::BasicAuth.new config +# +# source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:35 +class WEBrick::HTTPAuth::BasicAuth + include ::WEBrick::HTTPAuth::Authenticator + + # Creates a new BasicAuth instance. + # + # See WEBrick::Config::BasicAuth for default configuration entries + # + # You must supply the following configuration entries: + # + # :Realm:: The name of the realm being protected. + # :UserDB:: A database of usernames and passwords. + # A WEBrick::HTTPAuth::Htpasswd instance should be used. + # + # @return [BasicAuth] a new instance of BasicAuth + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:61 + def initialize(config, default = T.unsafe(nil)); end + + # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if + # the authentication was not correct. + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:70 + def authenticate(req, res); end + + # Returns a challenge response which asks for authentication information + # + # @raise [@auth_exception] + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:103 + def challenge(req, res); end + + # Returns the value of attribute logger. + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:48 + def logger; end + + # Returns the value of attribute realm. + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:48 + def realm; end + + # Returns the value of attribute userdb. + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:48 + def userdb; end + + class << self + # Used by UserDB to create a basic password entry + # + # source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:43 + def make_passwd(realm, user, pass); end + end +end + +# RFC 2617 Digest Access Authentication for WEBrick +# +# Use this class to add digest authentication to a WEBrick servlet. +# +# Here is an example of how to set up DigestAuth: +# +# config = { :Realm => 'DigestAuth example realm' } +# +# htdigest = WEBrick::HTTPAuth::Htdigest.new 'my_password_file' +# htdigest.set_passwd config[:Realm], 'username', 'password' +# htdigest.flush +# +# config[:UserDB] = htdigest +# +# digest_auth = WEBrick::HTTPAuth::DigestAuth.new config +# +# When using this as with a servlet be sure not to create a new DigestAuth +# object in the servlet's #initialize. By default WEBrick creates a new +# servlet instance for every request and the DigestAuth object must be +# used across requests. +# +# source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:46 +class WEBrick::HTTPAuth::DigestAuth + include ::WEBrick::HTTPAuth::Authenticator + + # Creates a new DigestAuth instance. Be sure to use the same DigestAuth + # instance for multiple requests as it saves state between requests in + # order to perform authentication. + # + # See WEBrick::Config::DigestAuth for default configuration entries + # + # You must supply the following configuration entries: + # + # :Realm:: The name of the realm being protected. + # :UserDB:: A database of usernames and passwords. + # A WEBrick::HTTPAuth::Htdigest instance should be used. + # + # @return [DigestAuth] a new instance of DigestAuth + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:87 + def initialize(config, default = T.unsafe(nil)); end + + # Digest authentication algorithm + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:59 + def algorithm; end + + # Authenticates a +req+ and returns a 401 Unauthorized using +res+ if + # the authentication was not correct. + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:121 + def authenticate(req, res); end + + # Returns a challenge response which asks for authentication information + # + # @raise [@auth_exception] + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:134 + def challenge(req, res, stale = T.unsafe(nil)); end + + # Quality of protection. RFC 2617 defines "auth" and "auth-int" + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:64 + def qop; end + + private + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:163 + def _authenticate(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:306 + def check_nonce(req, auth_req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:349 + def check_opaque(opaque_struct, req, auth_req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:365 + def check_uri(req, auth_req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:299 + def generate_next_nonce(req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:332 + def generate_opaque(req); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:376 + def hexdigest(*args); end + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:291 + def split_param_value(string); end + + class << self + # Used by UserDB to create a digest password entry + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:69 + def make_passwd(realm, user, pass); end + end +end + +# Struct containing the opaque portion of the digest authentication +# +# source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:54 +class WEBrick::HTTPAuth::DigestAuth::OpaqueInfo < ::Struct + # Sets the attribute nc + # + # @param value [Object] the value to set the attribute nc to. + # @return [Object] the newly set value + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:54 + def nc=(_); end + + # Sets the attribute nonce + # + # @param value [Object] the value to set the attribute nonce to. + # @return [Object] the newly set value + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:54 + def nonce=(_); end + + # Sets the attribute time + # + # @param value [Object] the value to set the attribute time to. + # @return [Object] the newly set value + # + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:54 + def time=(_); end +end + +# Htdigest accesses apache-compatible digest password files. Passwords are +# matched to a realm where they are valid. For security, the path for a +# digest password database should be stored outside of the paths available +# to the HTTP server. +# +# Htdigest is intended for use with WEBrick::HTTPAuth::DigestAuth and +# stores passwords using cryptographic hashes. +# +# htpasswd = WEBrick::HTTPAuth::Htdigest.new 'my_password_file' +# htpasswd.set_passwd 'my realm', 'username', 'password' +# htpasswd.flush +# +# source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:31 +class WEBrick::HTTPAuth::Htdigest + include ::WEBrick::HTTPAuth::UserDB + + # Open a digest password database at +path+ + # + # @return [Htdigest] a new instance of Htdigest + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:37 + def initialize(path); end + + # Removes a password from the database for +user+ in +realm+. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:113 + def delete_passwd(realm, user); end + + # Iterate passwords in the database. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:122 + def each; end + + # Flush the password database. If +output+ is given the database will + # be written there instead of to the original path. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:72 + def flush(output = T.unsafe(nil)); end + + # Retrieves a password from the database for +user+ in +realm+. If + # +reload_db+ is true the database will be reloaded first. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:91 + def get_passwd(realm, user, reload_db); end + + # Reloads passwords from the database + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:50 + def reload; end + + # Sets a password in the database for +user+ in +realm+ to +pass+. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htdigest.rb:101 + def set_passwd(realm, user, pass); end +end + +# Htgroup accesses apache-compatible group files. Htgroup can be used to +# provide group-based authentication for users. Currently Htgroup is not +# directly integrated with any authenticators in WEBrick. For security, +# the path for a digest password database should be stored outside of the +# paths available to the HTTP server. +# +# Example: +# +# htgroup = WEBrick::HTTPAuth::Htgroup.new 'my_group_file' +# htgroup.add 'superheroes', %w[spiderman batman] +# +# htgroup.members('superheroes').include? 'magneto' # => false +# +# source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:30 +class WEBrick::HTTPAuth::Htgroup + # Open a group database at +path+ + # + # @return [Htgroup] a new instance of Htgroup + # + # source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:35 + def initialize(path); end + + # Add an Array of +members+ to +group+ + # + # source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:92 + def add(group, members); end + + # Flush the group database. If +output+ is given the database will be + # written there instead of to the original path. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:64 + def flush(output = T.unsafe(nil)); end + + # Retrieve the list of members from +group+ + # + # source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:84 + def members(group); end + + # Reload groups from the database + # + # source://webrick-1.7.0/lib/webrick/httpauth/htgroup.rb:46 + def reload; end +end + +# Htpasswd accesses apache-compatible password files. Passwords are +# matched to a realm where they are valid. For security, the path for a +# password database should be stored outside of the paths available to the +# HTTP server. +# +# Htpasswd is intended for use with WEBrick::HTTPAuth::BasicAuth. +# +# To create an Htpasswd database with a single user: +# +# htpasswd = WEBrick::HTTPAuth::Htpasswd.new 'my_password_file' +# htpasswd.set_passwd 'my realm', 'username', 'password' +# htpasswd.flush +# +# source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:32 +class WEBrick::HTTPAuth::Htpasswd + include ::WEBrick::HTTPAuth::UserDB + + # Open a password database at +path+ + # + # @return [Htpasswd] a new instance of Htpasswd + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:38 + def initialize(path, password_hash: T.unsafe(nil)); end + + # Removes a password from the database for +user+ in +realm+. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:144 + def delete_passwd(realm, user); end + + # Iterate passwords in the database. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:151 + def each; end + + # Flush the password database. If +output+ is given the database will + # be written there instead of to the original path. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:103 + def flush(output = T.unsafe(nil)); end + + # Retrieves a password from the database for +user+ in +realm+. If + # +reload_db+ is true the database will be reloaded first. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:122 + def get_passwd(realm, user, reload_db); end + + # Reload passwords from the database + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:68 + def reload; end + + # Sets a password in the database for +user+ in +realm+ to +pass+. + # + # source://webrick-1.7.0/lib/webrick/httpauth/htpasswd.rb:130 + def set_passwd(realm, user, pass); end +end + +# source://webrick-1.7.0/lib/webrick/httpauth/authenticator.rb:114 +WEBrick::HTTPAuth::ProxyAuthenticator::AuthException = WEBrick::HTTPStatus::ProxyAuthenticationRequired + +# Basic authentication for proxy servers. See BasicAuth for details. +# +# source://webrick-1.7.0/lib/webrick/httpauth/basicauth.rb:112 +class WEBrick::HTTPAuth::ProxyBasicAuth < ::WEBrick::HTTPAuth::BasicAuth + include ::WEBrick::HTTPAuth::ProxyAuthenticator +end + +# Digest authentication for proxy servers. See DigestAuth for details. +# +# source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:386 +class WEBrick::HTTPAuth::ProxyDigestAuth < ::WEBrick::HTTPAuth::DigestAuth + include ::WEBrick::HTTPAuth::ProxyAuthenticator + + private + + # source://webrick-1.7.0/lib/webrick/httpauth/digestauth.rb:390 + def check_uri(req, auth_req); end +end + +# User database mixin for HTTPAuth. This mixin dispatches user record +# access to the underlying auth_type for this database. +# +# source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:18 +module WEBrick::HTTPAuth::UserDB + # The authentication type. + # + # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are + # built-in. + # + # source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:26 + def auth_type; end + + # The authentication type. + # + # WEBrick::HTTPAuth::BasicAuth or WEBrick::HTTPAuth::DigestAuth are + # built-in. + # + # source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:26 + def auth_type=(_arg0); end + + # Retrieves a password in +realm+ for +user+ for the auth_type of this + # database. +reload_db+ is a dummy value. + # + # source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:48 + def get_passwd(realm, user, reload_db = T.unsafe(nil)); end + + # Creates an obscured password in +realm+ with +user+ and +password+ + # using the auth_type of this database. + # + # source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:32 + def make_passwd(realm, user, pass); end + + # Sets a password in +realm+ with +user+ and +password+ for the + # auth_type of this database. + # + # source://webrick-1.7.0/lib/webrick/httpauth/userdb.rb:40 + def set_passwd(realm, user, pass); end +end + +# -- +# Adds SSL functionality to WEBrick::HTTPRequest +# +# source://webrick-1.7.0/lib/webrick/httprequest.rb:25 +class WEBrick::HTTPRequest + # Creates a new HTTP request. WEBrick::Config::HTTP is the default + # configuration. + # + # @return [HTTPRequest] a new instance of HTTPRequest + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:153 + def initialize(config); end + + # Retrieves +header_name+ + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:318 + def [](header_name); end + + # The Accept header value + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:100 + def accept; end + + # The Accept-Charset header value + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:105 + def accept_charset; end + + # The Accept-Encoding header value + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:110 + def accept_encoding; end + + # The Accept-Language header value + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:115 + def accept_language; end + + # The socket address of the server + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:127 + def addr; end + + # Hash of request attributes + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:137 + def attributes; end + + # Returns the request body. + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:255 + def body(&block); end + + # Prepares the HTTPRequest object for use as the + # source for IO.copy_stream + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:265 + def body_reader; end + + # The content-length header + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:304 + def content_length; end + + # The content-type header + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:311 + def content_type; end + + # Generate HTTP/1.1 100 continue response if the client expects it, + # otherwise does nothing. + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:245 + def continue; end + + # The parsed request cookies + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:95 + def cookies; end + + # Iterates over the request headers + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:328 + def each; end + + # Consumes any remaining body and updates keep-alive status + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:390 + def fixup; end + + # The parsed header of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:90 + def header; end + + # The host this request is for + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:340 + def host; end + + # The HTTP version of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:51 + def http_version; end + + # Is this a keep-alive connection? + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:142 + def keep_alive; end + + # Should the connection this request was made on be kept alive? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:375 + def keep_alive?; end + + # This method provides the metavariables defined by the revision 3 + # of "The WWW Common Gateway Interface Version 1.1" + # To browse the current document of CGI Version 1.1, see below: + # http://tools.ietf.org/html/rfc3875 + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:407 + def meta_vars; end + + # Parses a request from +socket+. This is called internally by + # WEBrick::HTTPServer. + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:193 + def parse(socket = T.unsafe(nil)); end + + # The request path + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:63 + def path; end + + # The path info (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:73 + def path_info; end + + # The path info (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:73 + def path_info=(_arg0); end + + # The socket address of the client + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:132 + def peeraddr; end + + # The port this request is for + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:347 + def port; end + + # Request query as a Hash + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:294 + def query; end + + # The query from the URI of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:78 + def query_string; end + + # The query from the URI of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:78 + def query_string=(_arg0); end + + # The raw header of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:85 + def raw_header; end + + # for IO.copy_stream. + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:278 + def readpartial(size, buf = T.unsafe(nil)); end + + # The client's IP address + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:361 + def remote_ip; end + + # The complete request line such as: + # + # GET / HTTP/1.1 + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:36 + def request_line; end + + # The request method, GET, POST, PUT, etc. + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:41 + def request_method; end + + # The local time this request was received + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:147 + def request_time; end + + # The parsed URI of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:58 + def request_uri; end + + # The script name (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:68 + def script_name; end + + # The script name (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:68 + def script_name=(_arg0); end + + # The server name this request is for + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:354 + def server_name; end + + # Is this an SSL request? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:368 + def ssl?; end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:379 + def to_s; end + + # The unparsed URI of the request + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:46 + def unparsed_uri; end + + # The remote user (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:122 + def user; end + + # The remote user (CGI variable) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:122 + def user=(_arg0); end + + private + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:562 + def _read_data(io, method, *arg); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:582 + def parse_query; end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:484 + def parse_uri(str, scheme = T.unsafe(nil)); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:507 + def read_body(socket, block); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:531 + def read_chunk_size(socket); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:542 + def read_chunked(socket, block); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:578 + def read_data(io, size); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:471 + def read_header(socket); end + + # source://webrick-1.7.0/lib/webrick/httprequest.rb:574 + def read_line(io, size = T.unsafe(nil)); end + + # @raise [HTTPStatus::EOFError] + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:451 + def read_request_line(socket); end + + # It's said that all X-Forwarded-* headers will contain more than one + # (comma-separated) value if the original request already contained one of + # these headers. Since we could use these values as Host header, we choose + # the initial(first) value. (apr_table_mergen() adds new value after the + # existing value with ", " prefix) + # + # source://webrick-1.7.0/lib/webrick/httprequest.rb:610 + def setup_forwarded_info; end +end + +# same as Mongrel, Thin and Puma +# +# source://webrick-1.7.0/lib/webrick/httprequest.rb:449 +WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer) + +# An HTTP response. This is filled in by the service or do_* methods of a +# WEBrick HTTP Servlet. +# +# source://webrick-1.7.0/lib/webrick/httpresponse.rb:24 +class WEBrick::HTTPResponse + # Creates a new HTTP response object. WEBrick::Config::HTTP is the + # default configuration. + # + # @return [HTTPResponse] a new instance of HTTPResponse + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:112 + def initialize(config); end + + # Retrieves the response header +field+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:150 + def [](field); end + + # Sets the response header +field+ to +value+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:157 + def []=(field, value); end + + # Body may be: + # * a String; + # * an IO-like object that responds to +#read+ and +#readpartial+; + # * a Proc-like object that responds to +#call+. + # + # In the latter case, either #chunked= should be set to +true+, + # or <code>header['content-length']</code> explicitly provided. + # Example: + # + # server.mount_proc '/' do |req, res| + # res.chunked = true + # # or + # # res.header['content-length'] = 10 + # res.body = proc { |out| out.write(Time.now.to_s) } + # end + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:70 + def body; end + + # Body may be: + # * a String; + # * an IO-like object that responds to +#read+ and +#readpartial+; + # * a Proc-like object that responds to +#call+. + # + # In the latter case, either #chunked= should be set to +true+, + # or <code>header['content-length']</code> explicitly provided. + # Example: + # + # server.mount_proc '/' do |req, res| + # res.chunked = true + # # or + # # res.header['content-length'] = 10 + # res.body = proc { |out| out.write(Time.now.to_s) } + # end + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:70 + def body=(_arg0); end + + # Enables chunked transfer encoding. + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:209 + def chunked=(val); end + + # Will this response body be returned using chunked transfer-encoding? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:202 + def chunked?; end + + # Configuration for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:101 + def config; end + + # The content-length header + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:165 + def content_length; end + + # Sets the content-length header to +len+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:174 + def content_length=(len); end + + # The content-type header + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:181 + def content_type; end + + # Sets the content-type header to +type+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:188 + def content_type=(type); end + + # Response cookies + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:46 + def cookies; end + + # Iterates over each header in the response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:195 + def each; end + + # Filename of the static file in this response. Only used by the + # FileHandler servlet. + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:91 + def filename; end + + # Filename of the static file in this response. Only used by the + # FileHandler servlet. + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:91 + def filename=(_arg0); end + + # Response header + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:41 + def header; end + + # HTTP Response version + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:31 + def http_version; end + + # Is this a keep-alive response? + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:96 + def keep_alive; end + + # Is this a keep-alive response? + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:96 + def keep_alive=(_arg0); end + + # Will this response's connection be kept alive? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:216 + def keep_alive?; end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:303 + def make_body_tempfile; end + + # Response reason phrase ("OK") + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:51 + def reason_phrase; end + + # Response reason phrase ("OK") + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:51 + def reason_phrase=(_arg0); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:321 + def remove_body_tempfile; end + + # Request HTTP version for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:85 + def request_http_version; end + + # Request HTTP version for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:85 + def request_http_version=(_arg0); end + + # Request method for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:75 + def request_method; end + + # Request method for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:75 + def request_method=(_arg0); end + + # Request URI for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:80 + def request_uri; end + + # Request URI for this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:80 + def request_uri=(_arg0); end + + # Sends the body on +socket+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:356 + def send_body(socket); end + + # Sends the headers on +socket+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:333 + def send_header(socket); end + + # Sends the response on +socket+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:223 + def send_response(socket); end + + # Bytes sent in this response + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:106 + def sent_size; end + + # Creates an error page for exception +ex+ with an optional +backtrace+ + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:383 + def set_error(ex, backtrace = T.unsafe(nil)); end + + # Redirects to +url+ with a WEBrick::HTTPStatus::Redirect +status+. + # + # Example: + # + # res.set_redirect WEBrick::HTTPStatus::TemporaryRedirect + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:373 + def set_redirect(status, url); end + + # Sets up the headers for sending + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:240 + def setup_header; end + + # Response status code (200) + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:36 + def status; end + + # Sets the response's status to the +status+ code + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:142 + def status=(status); end + + # The response's HTTP status line + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:135 + def status_line; end + + private + + # preserved for compatibility with some 3rd-party handlers + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:557 + def _write_data(socket, data); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:410 + def check_header(header_value); end + + # :stopdoc: + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:421 + def error_body(backtrace, ex, host, port); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:451 + def send_body_io(socket); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:513 + def send_body_proc(socket); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:491 + def send_body_string(socket); end +end + +# source://webrick-1.7.0/lib/webrick/httpresponse.rb:531 +class WEBrick::HTTPResponse::ChunkedWrapper + # @return [ChunkedWrapper] a new instance of ChunkedWrapper + # + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:532 + def initialize(socket, resp); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:550 + def <<(*buf); end + + # source://webrick-1.7.0/lib/webrick/httpresponse.rb:537 + def write(buf); end +end + +# -- +# Adds SSL functionality to WEBrick::HTTPServer +# +# source://webrick-1.7.0/lib/webrick/httpserver.rb:44 +class WEBrick::HTTPServer < ::WEBrick::GenericServer + # Creates a new HTTP server according to +config+ + # + # An HTTP server uses the following attributes: + # + # :AccessLog:: An array of access logs. See WEBrick::AccessLog + # :BindAddress:: Local address for the server to bind to + # :DocumentRoot:: Root path to serve files from + # :DocumentRootOptions:: Options for the default HTTPServlet::FileHandler + # :HTTPVersion:: The HTTP version of this server + # :Port:: Port to listen on + # :RequestCallback:: Called with a request and response before each + # request is serviced. + # :RequestTimeout:: Maximum time to wait between requests + # :ServerAlias:: Array of alternate names for this server for virtual + # hosting + # :ServerName:: Name for this server for virtual hosting + # + # @return [HTTPServer] a new instance of HTTPServer + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:46 + def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end + + # Logs +req+ and +res+ in the access logs. +config+ is used for the + # server name. + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:220 + def access_log(config, req, res); end + + # Creates the HTTPRequest used when handling the HTTP + # request. Can be overridden by subclasses. + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:230 + def create_request(with_webrick_config); end + + # Creates the HTTPResponse used when handling the HTTP + # request. Can be overridden by subclasses. + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:237 + def create_response(with_webrick_config); end + + # The default OPTIONS request handler says GET, HEAD, POST and OPTIONS + # requests are allowed. + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:147 + def do_OPTIONS(req, res); end + + # Finds the appropriate virtual host to handle +req+ + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:207 + def lookup_server(req); end + + # Mounts +servlet+ on +dir+ passing +options+ to the servlet at creation + # time + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:155 + def mount(dir, servlet, *options); end + + # Mounts +proc+ or +block+ on +dir+ and calls it with a + # WEBrick::HTTPRequest and WEBrick::HTTPResponse + # + # @raise [HTTPServerError] + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:164 + def mount_proc(dir, proc = T.unsafe(nil), &block); end + + # Processes requests on +sock+ + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:69 + def run(sock); end + + # Finds a servlet for +path+ + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:182 + def search_servlet(path); end + + # Services +req+ and fills in +res+ + # + # @raise [HTTPStatus::NotFound] + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:125 + def service(req, res); end + + # Unmounts +dir+ + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:173 + def umount(dir); end + + # Unmounts +dir+ + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:173 + def unmount(dir); end + + # Adds +server+ as a virtual host. + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:193 + def virtual_host(server); end +end + +# Mount table for the path a servlet is mounted on in the directory space +# of the server. Users of WEBrick can only access this indirectly via +# WEBrick::HTTPServer#mount, WEBrick::HTTPServer#unmount and +# WEBrick::HTTPServer#search_servlet +# +# source://webrick-1.7.0/lib/webrick/httpserver.rb:247 +class WEBrick::HTTPServer::MountTable + # @return [MountTable] a new instance of MountTable + # + # source://webrick-1.7.0/lib/webrick/httpserver.rb:248 + def initialize; end + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:253 + def [](dir); end + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:258 + def []=(dir, val); end + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:265 + def delete(dir); end + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:272 + def scan(path); end + + private + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:279 + def compile; end + + # source://webrick-1.7.0/lib/webrick/httpserver.rb:287 + def normalize(dir); end +end + +# AbstractServlet allows HTTP server modules to be reused across multiple +# servers and allows encapsulation of functionality. +# +# By default a servlet will respond to GET, HEAD (through an alias to GET) +# and OPTIONS requests. +# +# By default a new servlet is initialized for every request. A servlet +# instance can be reused by overriding ::get_instance in the +# AbstractServlet subclass. +# +# == A Simple Servlet +# +# class Simple < WEBrick::HTTPServlet::AbstractServlet +# def do_GET request, response +# status, content_type, body = do_stuff_with request +# +# response.status = status +# response['Content-Type'] = content_type +# response.body = body +# end +# +# def do_stuff_with request +# return 200, 'text/plain', 'you got a page' +# end +# end +# +# This servlet can be mounted on a server at a given path: +# +# server.mount '/simple', Simple +# +# == Servlet Configuration +# +# Servlets can be configured via initialize. The first argument is the +# HTTP server the servlet is being initialized for. +# +# class Configurable < Simple +# def initialize server, color, size +# super server +# @color = color +# @size = size +# end +# +# def do_stuff_with request +# content = "<p " \ +# %q{style="color: #{@color}; font-size: #{@size}"} \ +# ">Hello, World!" +# +# return 200, "text/html", content +# end +# end +# +# This servlet must be provided two arguments at mount time: +# +# server.mount '/configurable', Configurable, 'red', '2em' +# +# source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:76 +class WEBrick::HTTPServlet::AbstractServlet + # Initializes a new servlet for +server+ using +options+ which are + # stored as-is in +@options+. +@logger+ is also provided. + # + # @return [AbstractServlet] a new instance of AbstractServlet + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:91 + def initialize(server, *options); end + + # Raises a NotFound exception + # + # @raise [HTTPStatus::NotFound] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:115 + def do_GET(req, res); end + + # Dispatches to do_GET + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:122 + def do_HEAD(req, res); end + + # Returns the allowed HTTP request methods + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:129 + def do_OPTIONS(req, res); end + + # Dispatches to a +do_+ method based on +req+ if such a method is + # available. (+do_GET+ for a GET request). Raises a MethodNotAllowed + # exception if the method is not implemented. + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:102 + def service(req, res); end + + private + + # Redirects to a path ending in / + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:140 + def redirect_to_directory_uri(req, res); end + + class << self + # Factory for servlet instances that will handle a request from +server+ + # using +options+ from the mount point. By default a new servlet + # instance is created for every call. + # + # source://webrick-1.7.0/lib/webrick/httpservlet/abstract.rb:83 + def get_instance(server, *options); end + end +end + +# Servlet for handling CGI scripts +# +# Example: +# +# server.mount('/cgi/my_script', WEBrick::HTTPServlet::CGIHandler, +# '/path/to/my_script') +# +# source://webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb:28 +class WEBrick::HTTPServlet::CGIHandler < ::WEBrick::HTTPServlet::AbstractServlet + # Creates a new CGI script servlet for the script at +name+ + # + # @return [CGIHandler] a new instance of CGIHandler + # + # source://webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb:36 + def initialize(server, name); end + + # :stopdoc: + # + # @raise [HTTPStatus::InternalServerError] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb:50 + def do_GET(req, res); end + + # :stopdoc: + # + # @raise [HTTPStatus::InternalServerError] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb:50 + def do_POST(req, res); end +end + +# source://webrick-1.7.0/lib/webrick/httpservlet/cgihandler.rb:31 +WEBrick::HTTPServlet::CGIHandler::CGIRunnerArray = T.let(T.unsafe(nil), Array) + +# Servlet for serving a single file. You probably want to use the +# FileHandler servlet instead as it handles directories and fancy indexes. +# +# Example: +# +# server.mount('/my_page.txt', WEBrick::HTTPServlet::DefaultFileHandler, +# '/path/to/my_page.txt') +# +# This servlet handles If-Modified-Since and Range requests. +# +# source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:32 +class WEBrick::HTTPServlet::DefaultFileHandler < ::WEBrick::HTTPServlet::AbstractServlet + # Creates a DefaultFileHandler instance for the file at +local_path+. + # + # @return [DefaultFileHandler] a new instance of DefaultFileHandler + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:37 + def initialize(server, local_path); end + + # :stopdoc: + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:44 + def do_GET(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:118 + def make_partial_content(req, res, filename, filesize); end + + # returns a lambda for webrick/httpresponse.rb send_body_proc + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:90 + def multipart_body(body, parts, boundary, mtype, filesize); end + + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:64 + def not_modified?(req, res, mtime, etag); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:155 + def prepare_range(range, filesize); end +end + +# ERBHandler evaluates an ERB file and returns the result. This handler +# is automatically used if there are .rhtml files in a directory served by +# the FileHandler. +# +# ERBHandler supports GET and POST methods. +# +# The ERB file is evaluated with the local variables +servlet_request+ and +# +servlet_response+ which are a WEBrick::HTTPRequest and +# WEBrick::HTTPResponse respectively. +# +# Example .rhtml file: +# +# Request to <%= servlet_request.request_uri %> +# +# Query params <%= servlet_request.query.inspect %> +# +# source://webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb:36 +class WEBrick::HTTPServlet::ERBHandler < ::WEBrick::HTTPServlet::AbstractServlet + # Creates a new ERBHandler on +server+ that will evaluate and serve the + # ERB file +name+ + # + # @return [ERBHandler] a new instance of ERBHandler + # + # source://webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb:42 + def initialize(server, name); end + + # Handles GET requests + # + # source://webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb:50 + def do_GET(req, res); end + + # Handles GET requests + # + # Handles POST requests + # + # source://webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb:50 + def do_POST(req, res); end + + private + + # Evaluates +erb+ providing +servlet_request+ and +servlet_response+ as + # local variables. + # + # source://webrick-1.7.0/lib/webrick/httpservlet/erbhandler.rb:79 + def evaluate(erb, servlet_request, servlet_response); end +end + +# Serves a directory including fancy indexing and a variety of other +# options. +# +# Example: +# +# server.mount('/assets', WEBrick::HTTPServlet::FileHandler, +# '/path/to/assets') +# +# source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:175 +class WEBrick::HTTPServlet::FileHandler < ::WEBrick::HTTPServlet::AbstractServlet + # Creates a FileHandler servlet on +server+ that serves files starting + # at directory +root+ + # + # +options+ may be a Hash containing keys from + # WEBrick::Config::FileHandler or +true+ or +false+. + # + # If +options+ is true or false then +:FancyIndexing+ is enabled or + # disabled respectively. + # + # @return [FileHandler] a new instance of FileHandler + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:203 + def initialize(server, root, options = T.unsafe(nil), default = T.unsafe(nil)); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:245 + def do_GET(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:257 + def do_OPTIONS(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:251 + def do_POST(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:224 + def service(req, res); end + + # :stopdoc: + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:215 + def set_filesystem_encoding(str); end + + private + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:416 + def call_callback(callback_name, req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:369 + def check_filename(req, res, name); end + + # @raise [HTTPStatus::NotFound] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:309 + def exec_handler(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:322 + def get_handler(req, res); end + + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:428 + def nondisclosure_name?(name); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:286 + def prevent_directory_traversal(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:394 + def search_file(req, res, basename); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:385 + def search_index_file(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:437 + def set_dir_list(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:335 + def set_filename(req, res); end + + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:376 + def shift_path_info(req, res, path_info, base = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:277 + def trailing_pathsep?(path); end + + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:422 + def windows_ambiguous_name?(name); end + + class << self + # Allow custom handling of requests for files with +suffix+ by class + # +handler+ + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:182 + def add_handler(suffix, handler); end + + # Remove custom handling of requests for files with +suffix+ + # + # source://webrick-1.7.0/lib/webrick/httpservlet/filehandler.rb:189 + def remove_handler(suffix); end + end +end + +# This module is used to manager HTTP status codes. +# +# See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html for more +# information. +# +# source://webrick-1.7.0/lib/webrick/httpstatus.rb:21 +module WEBrick::HTTPStatus + private + + # Is +code+ a client error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:170 + def client_error?(code); end + + # Is +code+ an error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:164 + def error?(code); end + + # Is +code+ an informational status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:146 + def info?(code); end + + # Returns the description corresponding to the HTTP status +code+ + # + # WEBrick::HTTPStatus.reason_phrase 404 + # => "Not Found" + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:140 + def reason_phrase(code); end + + # Is +code+ a redirection status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:158 + def redirect?(code); end + + # Is +code+ a server error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:176 + def server_error?(code); end + + # Is +code+ a successful status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:152 + def success?(code); end + + class << self + # Returns the status class corresponding to +code+ + # + # WEBrick::HTTPStatus[302] + # => WEBrick::HTTPStatus::NotFound + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:186 + def [](code); end + + # Is +code+ a client error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:170 + def client_error?(code); end + + # Is +code+ an error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:164 + def error?(code); end + + # Is +code+ an informational status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:146 + def info?(code); end + + # Returns the description corresponding to the HTTP status +code+ + # + # WEBrick::HTTPStatus.reason_phrase 404 + # => "Not Found" + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:140 + def reason_phrase(code); end + + # Is +code+ a redirection status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:158 + def redirect?(code); end + + # Is +code+ a server error status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:176 + def server_error?(code); end + + # Is +code+ a successful status? + # + # @return [Boolean] + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:152 + def success?(code); end + end +end + +# Root of the HTTP status class hierarchy +# +# source://webrick-1.7.0/lib/webrick/httpstatus.rb:25 +class WEBrick::HTTPStatus::Status < ::StandardError + # Returns the HTTP status code + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:31 + def code; end + + # Returns the HTTP status description + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:34 + def reason_phrase; end + + # Returns the HTTP status code + # + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:31 + def to_i; end + + class << self + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:27 + def code; end + + # source://webrick-1.7.0/lib/webrick/httpstatus.rb:27 + def reason_phrase; end + end +end + +# HTTPUtils provides utility methods for working with the HTTP protocol. +# +# This module is generally used internally by WEBrick +# +# source://webrick-1.7.0/lib/webrick/httputils.rb:25 +module WEBrick::HTTPUtils + private + + # source://webrick-1.7.0/lib/webrick/httputils.rb:443 + def _escape(str, regex); end + + # :stopdoc: + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:441 + def _make_regex(str); end + + # source://webrick-1.7.0/lib/webrick/httputils.rb:442 + def _make_regex!(str); end + + # source://webrick-1.7.0/lib/webrick/httputils.rb:449 + def _unescape(str, regex); end + + # Removes quotes and escapes from +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:223 + def dequote(str); end + + # Escapes HTTP reserved and unwise characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:467 + def escape(str); end + + # Escapes 8 bit characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:508 + def escape8bit(str); end + + # Escapes form reserved characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:481 + def escape_form(str); end + + # Escapes path +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:497 + def escape_path(str); end + + # Loads Apache-compatible mime.types in +file+. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:112 + def load_mime_types(file); end + + # Returns the mime type of +filename+ from the list in +mime_tab+. If no + # mime type was found application/octet-stream is returned. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:134 + def mime_type(filename, mime_tab); end + + # Normalizes a request path. Raises an exception if the path cannot be + # normalized. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:31 + def normalize_path(path); end + + # Parses form data in +io+ with the given +boundary+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:395 + def parse_form_data(io, boundary); end + + # Parses an HTTP header +raw+ into a hash of header fields with an Array + # of values. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:145 + def parse_header(raw); end + + # Parses the query component of a URI in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:371 + def parse_query(str); end + + # Parses q values in +value+ as used in Accept headers. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:202 + def parse_qvalues(value); end + + # Parses a Range header value +ranges_specifier+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:184 + def parse_range_header(ranges_specifier); end + + # Quotes and escapes quotes in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:233 + def quote(str); end + + # Splits a header value +str+ according to HTTP specification. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:175 + def split_header_value(str); end + + # Unescapes HTTP reserved and unwise characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:474 + def unescape(str); end + + # Unescapes form reserved characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:490 + def unescape_form(str); end + + class << self + # source://webrick-1.7.0/lib/webrick/httputils.rb:443 + def _escape(str, regex); end + + # :stopdoc: + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:441 + def _make_regex(str); end + + # source://webrick-1.7.0/lib/webrick/httputils.rb:442 + def _make_regex!(str); end + + # source://webrick-1.7.0/lib/webrick/httputils.rb:449 + def _unescape(str, regex); end + + # Removes quotes and escapes from +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:223 + def dequote(str); end + + # Escapes HTTP reserved and unwise characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:467 + def escape(str); end + + # Escapes 8 bit characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:508 + def escape8bit(str); end + + # Escapes form reserved characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:481 + def escape_form(str); end + + # Escapes path +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:497 + def escape_path(str); end + + # Loads Apache-compatible mime.types in +file+. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:112 + def load_mime_types(file); end + + # Returns the mime type of +filename+ from the list in +mime_tab+. If no + # mime type was found application/octet-stream is returned. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:134 + def mime_type(filename, mime_tab); end + + # Normalizes a request path. Raises an exception if the path cannot be + # normalized. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:31 + def normalize_path(path); end + + # Parses form data in +io+ with the given +boundary+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:395 + def parse_form_data(io, boundary); end + + # Parses an HTTP header +raw+ into a hash of header fields with an Array + # of values. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:145 + def parse_header(raw); end + + # Parses the query component of a URI in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:371 + def parse_query(str); end + + # Parses q values in +value+ as used in Accept headers. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:202 + def parse_qvalues(value); end + + # Parses a Range header value +ranges_specifier+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:184 + def parse_range_header(ranges_specifier); end + + # Quotes and escapes quotes in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:233 + def quote(str); end + + # Splits a header value +str+ according to HTTP specification. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:175 + def split_header_value(str); end + + # Unescapes HTTP reserved and unwise characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:474 + def unescape(str); end + + # Unescapes form reserved characters in +str+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:490 + def unescape_form(str); end + end +end + +# Stores multipart form data. FormData objects are created when +# WEBrick::HTTPUtils.parse_form_data is called. +# +# source://webrick-1.7.0/lib/webrick/httputils.rb:242 +class WEBrick::HTTPUtils::FormData < ::String + # Creates a new FormData object. + # + # +args+ is an Array of form data entries. One FormData will be created + # for each entry. + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you + # + # @return [FormData] a new instance of FormData + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:267 + def initialize(*args); end + + # Adds +str+ to this FormData which may be the body, a header or a + # header entry. + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:300 + def <<(str); end + + # Retrieves the header at the first entry in +key+ + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:286 + def [](*key); end + + # Adds +data+ at the end of the chain of entries + # + # This is called by WEBrick::HTTPUtils.parse_form_data for you. + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:320 + def append_data(data); end + + # Yields each entry in this FormData + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:335 + def each_data; end + + # The filename of the form data part + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:254 + def filename; end + + # The filename of the form data part + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:254 + def filename=(_arg0); end + + # Returns all the FormData as an Array + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:347 + def list; end + + # The name of the form data part + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:249 + def name; end + + # The name of the form data part + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:249 + def name=(_arg0); end + + # source://webrick-1.7.0/lib/webrick/httputils.rb:256 + def next_data=(_arg0); end + + # Returns all the FormData as an Array + # + # A FormData will behave like an Array + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:347 + def to_ary; end + + # This FormData's body + # + # source://webrick-1.7.0/lib/webrick/httputils.rb:363 + def to_s; end + + protected + + # source://webrick-1.7.0/lib/webrick/httputils.rb:256 + def next_data; end +end + +# source://webrick-1.7.0/lib/webrick/utils.rb:17 +module WEBrick::Utils + private + + # Creates TCP server sockets bound to +address+:+port+ and returns them. + # + # It will create IPV4 and IPV6 sockets on all interfaces. + # + # source://webrick-1.7.0/lib/webrick/utils.rb:56 + def create_listeners(address, port); end + + # The server hostname + # + # source://webrick-1.7.0/lib/webrick/utils.rb:47 + def getservername; end + + # Generates a random string of length +len+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:79 + def random_string(len); end + + # Sets the close on exec flag for +io+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:27 + def set_close_on_exec(io); end + + # Sets IO operations on +io+ to be non-blocking + # + # source://webrick-1.7.0/lib/webrick/utils.rb:20 + def set_non_blocking(io); end + + # Changes the process's uid and gid to the ones of +user+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:34 + def su(user); end + + # Executes the passed block and raises +exception+ if execution takes more + # than +seconds+. + # + # If +seconds+ is zero or nil, simply executes the block + # + # source://webrick-1.7.0/lib/webrick/utils.rb:253 + def timeout(seconds, exception = T.unsafe(nil)); end + + class << self + # Creates TCP server sockets bound to +address+:+port+ and returns them. + # + # It will create IPV4 and IPV6 sockets on all interfaces. + # + # source://webrick-1.7.0/lib/webrick/utils.rb:56 + def create_listeners(address, port); end + + # The server hostname + # + # source://webrick-1.7.0/lib/webrick/utils.rb:47 + def getservername; end + + # Generates a random string of length +len+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:79 + def random_string(len); end + + # Sets the close on exec flag for +io+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:27 + def set_close_on_exec(io); end + + # Sets IO operations on +io+ to be non-blocking + # + # source://webrick-1.7.0/lib/webrick/utils.rb:20 + def set_non_blocking(io); end + + # Changes the process's uid and gid to the ones of +user+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:34 + def su(user); end + + # Executes the passed block and raises +exception+ if execution takes more + # than +seconds+. + # + # If +seconds+ is zero or nil, simply executes the block + # + # source://webrick-1.7.0/lib/webrick/utils.rb:253 + def timeout(seconds, exception = T.unsafe(nil)); end + end +end + +# Class used to manage timeout handlers across multiple threads. +# +# Timeout handlers should be managed by using the class methods which are +# synchronized. +# +# id = TimeoutHandler.register(10, Timeout::Error) +# begin +# sleep 20 +# puts 'foo' +# ensure +# TimeoutHandler.cancel(id) +# end +# +# will raise Timeout::Error +# +# id = TimeoutHandler.register(10, Timeout::Error) +# begin +# sleep 5 +# puts 'foo' +# ensure +# TimeoutHandler.cancel(id) +# end +# +# will print 'foo' +# +# source://webrick-1.7.0/lib/webrick/utils.rb:118 +class WEBrick::Utils::TimeoutHandler + include ::Singleton + extend ::Singleton::SingletonClassMethods + + # Creates a new TimeoutHandler. You should use ::register and ::cancel + # instead of creating the timeout handler directly. + # + # @return [TimeoutHandler] a new instance of TimeoutHandler + # + # source://webrick-1.7.0/lib/webrick/utils.rb:148 + def initialize; end + + # Cancels the timeout handler +id+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:226 + def cancel(thread, id); end + + # Interrupts the timeout handler +id+ and raises +exception+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:203 + def interrupt(thread, id, exception); end + + # Registers a new timeout handler + # + # +time+:: Timeout in seconds + # +exception+:: Exception to raise when timeout elapsed + # + # source://webrick-1.7.0/lib/webrick/utils.rb:214 + def register(thread, time, exception); end + + # source://webrick-1.7.0/lib/webrick/utils.rb:240 + def terminate; end + + private + + # source://webrick-1.7.0/lib/webrick/utils.rb:158 + def watch; end + + # source://webrick-1.7.0/lib/webrick/utils.rb:193 + def watcher; end + + class << self + # Cancels the timeout handler +id+ + # + # source://webrick-1.7.0/lib/webrick/utils.rb:137 + def cancel(id); end + + # Registers a new timeout handler + # + # +time+:: Timeout in seconds + # +exception+:: Exception to raise when timeout elapsed + # + # source://webrick-1.7.0/lib/webrick/utils.rb:130 + def register(seconds, exception); end + + # source://webrick-1.7.0/lib/webrick/utils.rb:141 + def terminate; end + end +end diff --git a/sorbet/rbi/gems/yard.rbi b/sorbet/rbi/gems/yard.rbi deleted file mode 100644 index 50fe5894..00000000 --- a/sorbet/rbi/gems/yard.rbi +++ /dev/null @@ -1,1229 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi gems - -# typed: false -# -# If you would like to make changes to this file, great! Please create the gem's shim here: -# -# https://github.com/sorbet/sorbet-typed/new/master?filename=lib/yard/all/yard.rbi -# -# yard-0.9.28 - -module YARD - def self.load_plugins; end - def self.parse(*args); end - def self.parse_string(*args); end - def self.ruby18?; end - def self.ruby19?; end - def self.ruby2?; end - def self.ruby31?; end - def self.ruby3?; end - def self.windows?; end -end -module YARD::Server - def self.register_static_path(path); end -end -class Object < BasicObject - def P(namespace, name = nil, type = nil); end - def log; end -end -module YARD::CLI -end -module YARD::CodeObjects - extend YARD::CodeObjects::NamespaceMapper -end -module YARD::Handlers -end -module YARD::Handlers::Common -end -module YARD::Handlers::C -end -module YARD::Handlers::Ruby -end -module YARD::Handlers::Ruby::Legacy -end -module YARD::I18n -end -module YARD::Parser -end -module YARD::Parser::C -end -module YARD::Parser::Ruby - def s(*args); end -end -module YARD::Parser::Ruby::Legacy -end -module YARD::Rake -end -module YARD::Serializers -end -module YARD::Server::Commands -end -module YARD::Tags -end -module YARD::Templates -end -module YARD::Templates::Helpers -end -module YARD::Templates::Helpers::Markup -end -class YARD::Config - def self.add_ignored_plugins_file; end - def self.arguments; end - def self.load; end - def self.load_autoload_plugins; end - def self.load_commandline_plugins; end - def self.load_commandline_safemode; end - def self.load_gem_plugins; end - def self.load_plugin(name); end - def self.load_plugin_failed(name, exception); end - def self.load_plugins; end - def self.options; end - def self.options=(arg0); end - def self.read_config_file; end - def self.save; end - def self.translate_plugin_name(name); end - def self.translate_plugin_names; end - def self.with_yardopts; end -end -class String - def shell_split; end -end -class Module - def class_name; end -end -class Array - def place(*values); end -end -class SymbolHash < Hash - def [](key); end - def []=(key, value); end - def delete(key); end - def has_key?(key); end - def initialize(symbolize_value = nil); end - def key?(key); end - def merge!(hash); end - def merge(hash); end - def self.[](*hsh); end - def update(hash); end -end -class Insertion - def after(val, recursive = nil); end - def after_any(val); end - def before(val, recursive = nil); end - def before_any(val); end - def initialize(list, value); end - def insertion(val, rel, recursive = nil, list = nil); end -end -class File < IO - def self.chown(*arg0); end - def self.lchmod(*arg0); end - def self.lchown(*arg0); end - def self.lutime(*arg0); end -end -module Gem - def self.source_index; end -end -class Gem::SourceIndex - def ==(other); end - def add_spec(gem_spec, name = nil); end - def add_specs(*gem_specs); end - def all_gems; end - def dump; end - def each(&block); end - def find_name(gem_name, requirement = nil); end - def gem_signature(gem_full_name); end - def gems; end - def index_signature; end - def initialize(specifications = nil); end - def latest_specs(include_prerelease = nil); end - def length; end - def load_gems_in(*spec_dirs); end - def outdated; end - def prerelease_gems; end - def prerelease_specs; end - def refresh!; end - def released_gems; end - def released_specs; end - def remove_spec(full_name); end - def search(gem_pattern, platform_only = nil); end - def self.from_gems_in(*spec_dirs); end - def self.from_installed_gems(*deprecated); end - def self.installed_spec_directories; end - def self.load_specification(file_name); end - def size; end - def spec_dirs; end - def spec_dirs=(arg0); end - def specification(full_name); end - include Enumerable -end -class YARD::Options - def ==(other); end - def [](key); end - def []=(key, value); end - def delete(key); end - def each; end - def inspect; end - def merge(opts); end - def method_missing(meth, *args, &block); end - def reset_defaults; end - def self.default_attr(key, default); end - def to_hash; end - def update(opts); end -end -class YARD::Templates::TemplateOptions < YARD::Options - def __globals; end - def default_return; end - def default_return=(arg0); end - def embed_mixins; end - def embed_mixins=(arg0); end - def embed_mixins_match?(mixin); end - def format; end - def format=(arg0); end - def globals; end - def globals=(arg0); end - def hide_void_return; end - def hide_void_return=(arg0); end - def highlight; end - def highlight=(arg0); end - def index; end - def index=(arg0); end - def markup; end - def markup=(arg0); end - def markup_provider; end - def markup_provider=(arg0); end - def no_highlight; end - def no_highlight=(value); end - def object; end - def object=(arg0); end - def owner; end - def owner=(arg0); end - def page_title; end - def page_title=(arg0); end - def serialize; end - def serialize=(arg0); end - def serializer; end - def serializer=(arg0); end - def template; end - def template=(arg0); end - def type; end - def type=(arg0); end - def verifier; end - def verifier=(arg0); end -end -class YARD::CLI::Command - def common_options(opts); end - def description; end - def load_script(file); end - def parse_options(opts, args); end - def self.run(*args); end - def unrecognized_option(err); end -end -class YARD::CLI::YardoptsCommand < YARD::CLI::Command - def initialize; end - def options_file; end - def options_file=(arg0); end - def parse_arguments(*args); end - def parse_rdoc_document_file(file = nil); end - def parse_yardopts(file = nil); end - def parse_yardopts_options(*args); end - def support_rdoc_document_file!(file = nil); end - def use_document_file; end - def use_document_file=(arg0); end - def use_yardopts_file; end - def use_yardopts_file=(arg0); end - def yardopts(file = nil); end - def yardopts_options(opts); end -end -class YARD::CLI::YardocOptions < YARD::Templates::TemplateOptions - def file; end - def file=(arg0); end - def files; end - def files=(arg0); end - def format; end - def format=(arg0); end - def index; end - def index=(arg0); end - def item; end - def item=(arg0); end - def locale; end - def locale=(arg0); end - def objects; end - def objects=(arg0); end - def onefile; end - def onefile=(arg0); end - def readme; end - def readme=(arg0); end - def serializer; end - def serializer=(arg0); end - def title; end - def title=(arg0); end - def verifier; end - def verifier=(arg0); end -end -class YARD::CLI::Yardoc < YARD::CLI::YardoptsCommand - def add_api_verifier; end - def add_extra_files(*files); end - def add_tag(tag_data, factory_method = nil); end - def add_visibility_verifier; end - def all_objects; end - def apis; end - def apis=(arg0); end - def apply_locale; end - def assets; end - def assets=(arg0); end - def copy_assets; end - def description; end - def excluded; end - def excluded=(arg0); end - def extra_file_valid?(file, check_exists = nil); end - def fail_on_warning; end - def fail_on_warning=(arg0); end - def files; end - def files=(arg0); end - def general_options(opts); end - def generate; end - def generate=(arg0); end - def has_markup; end - def has_markup=(arg0); end - def hidden_apis; end - def hidden_apis=(arg0); end - def hidden_tags; end - def hidden_tags=(arg0); end - def initialize; end - def list; end - def list=(arg0); end - def options; end - def optparse(*args); end - def output_options(opts); end - def parse_arguments(*args); end - def parse_files(*files); end - def print_list; end - def run(*args); end - def run_generate(checksums); end - def run_verifier(list); end - def save_yardoc; end - def save_yardoc=(arg0); end - def statistics; end - def statistics=(arg0); end - def tag_options(opts); end - def use_cache; end - def use_cache=(arg0); end - def verify_markup_options; end - def visibilities; end - def visibilities=(arg0); end -end -class YARD::Logger < Logger - def <<(msg = nil); end - def add(*args); end - def backtrace(exc, level_meth = nil); end - def capture(msg, nontty_log = nil); end - def clear_line; end - def clear_progress; end - def debug(*args); end - def enter_level(new_level = nil); end - def format_log(sev, _time, _prog, msg); end - def initialize(pipe, *args); end - def io; end - def io=(pipe); end - def print(msg = nil); end - def print_no_newline(msg); end - def progress(msg, nontty_log = nil); end - def puts(msg = nil); end - def self.instance(pipe = nil); end - def show_backtraces; end - def show_backtraces=(arg0); end - def show_progress; end - def show_progress=(arg0); end - def warn(*args); end - def warn_no_continuations; end - def warned; end - def warned=(arg0); end -end -class YARD::Parser::Base - def enumerator; end - def initialize(source, filename); end - def parse; end - def self.parse(source, filename = nil); end - def tokenize; end -end -class YARD::Parser::Ruby::AstNode < Array - def ==(other); end - def block?; end - def call?; end - def children; end - def comments; end - def comments_hash_flag; end - def comments_range; end - def condition?; end - def def?; end - def docstring; end - def docstring=(arg0); end - def docstring_hash_flag; end - def docstring_hash_flag=(arg0); end - def docstring_range; end - def docstring_range=(arg0); end - def file; end - def file=(arg0); end - def first_line; end - def full_source; end - def full_source=(arg0); end - def group; end - def group=(arg0); end - def has_line?; end - def initialize(type, arr, opts = nil); end - def inspect; end - def jump(*node_types); end - def kw?; end - def line; end - def line_range; end - def line_range=(arg0); end - def literal?; end - def loop?; end - def parent; end - def parent=(arg0); end - def pretty_print(q); end - def ref?; end - def reset_line_info; end - def self.node_class_for(type); end - def show; end - def source; end - def source=(arg0); end - def source_range; end - def source_range=(arg0); end - def to_s; end - def token?; end - def traverse; end - def type; end - def type=(arg0); end - def unfreeze; end -end -class YARD::Parser::Ruby::ReferenceNode < YARD::Parser::Ruby::AstNode - def namespace; end - def path; end - def ref?; end -end -class YARD::Parser::Ruby::LiteralNode < YARD::Parser::Ruby::AstNode - def literal?; end -end -class YARD::Parser::Ruby::KeywordNode < YARD::Parser::Ruby::AstNode - def kw?; end -end -class YARD::Parser::Ruby::ParameterNode < YARD::Parser::Ruby::AstNode - def args_forward; end - def block_param; end - def double_splat_param; end - def named_params; end - def splat_param; end - def unnamed_end_params; end - def unnamed_optional_params; end - def unnamed_required_params; end -end -class YARD::Parser::Ruby::MethodCallNode < YARD::Parser::Ruby::AstNode - def block; end - def block_param; end - def call?; end - def call_has_paren?; end - def index_adjust; end - def method_name(name_only = nil); end - def namespace; end - def parameters(include_block_param = nil); end -end -class YARD::Parser::Ruby::MethodDefinitionNode < YARD::Parser::Ruby::AstNode - def block(*arg0); end - def def?; end - def index_adjust; end - def kw?; end - def method_name(name_only = nil); end - def namespace; end - def parameters(include_block_param = nil); end - def signature; end -end -class YARD::Parser::Ruby::ConditionalNode < YARD::Parser::Ruby::KeywordNode - def cmod?; end - def condition; end - def condition?; end - def else_block; end - def then_block; end -end -class YARD::Parser::Ruby::ClassNode < YARD::Parser::Ruby::KeywordNode - def block; end - def class_name; end - def superclass; end -end -class YARD::Parser::Ruby::ModuleNode < YARD::Parser::Ruby::KeywordNode - def block; end - def module_name; end -end -class YARD::Parser::Ruby::LoopNode < YARD::Parser::Ruby::KeywordNode - def block; end - def condition; end - def loop?; end -end -class YARD::Parser::Ruby::CommentNode < YARD::Parser::Ruby::AstNode - def comments; end - def docstring; end - def docstring=(value); end - def first_line; end - def source; end -end -class YARD::Parser::Ruby::RubyParser < YARD::Parser::Base - def encoding_line; end - def enumerator; end - def frozen_string_line; end - def initialize(source, filename); end - def parse; end - def shebang_line; end - def tokenize; end -end -class YARD::Parser::Ruby::RipperParser < Ripper - def add_comment(line, node = nil, before_node = nil, into = nil); end - def add_token(token, data); end - def ast; end - def charno; end - def comment_starts_line?(charno); end - def comments; end - def compile_error(msg); end - def encoding_line; end - def enumerator; end - def file; end - def file_encoding; end - def freeze_tree(node = nil); end - def frozen_string_line; end - def initialize(source, filename, *args); end - def insert_comments; end - def on_BEGIN(*args); end - def on_CHAR(tok); end - def on_END(*args); end - def on___end__(tok); end - def on_alias(*args); end - def on_alias_error(*args); end - def on_aref(*args); end - def on_aref_field(*args); end - def on_arg_ambiguous(*args); end - def on_arg_paren(*args); end - def on_args_add(list, item); end - def on_args_add_block(list, item); end - def on_args_add_star(list, item); end - def on_args_forward(*args); end - def on_args_new(*args); end - def on_array(other); end - def on_aryptn(*args); end - def on_assign(*args); end - def on_assign_error(*args); end - def on_assoc_new(*args); end - def on_assoc_splat(*args); end - def on_assoclist_from_args(*args); end - def on_backref(tok); end - def on_backtick(tok); end - def on_bare_assoc_hash(*args); end - def on_begin(*args); end - def on_binary(*args); end - def on_block_var(*args); end - def on_blockarg(*args); end - def on_body_stmt(*args); end - def on_bodystmt(*args); end - def on_brace_block(*args); end - def on_break(*args); end - def on_call(*args); end - def on_case(*args); end - def on_class(*args); end - def on_class_name_error(*args); end - def on_comma(tok); end - def on_command(*args); end - def on_command_call(*args); end - def on_comment(comment); end - def on_const(tok); end - def on_const_path_field(*args); end - def on_const_path_ref(*args); end - def on_const_ref(*args); end - def on_cvar(tok); end - def on_def(*args); end - def on_defined(*args); end - def on_defs(*args); end - def on_do_block(*args); end - def on_dot2(*args); end - def on_dot3(*args); end - def on_dyna_symbol(sym); end - def on_else(*args); end - def on_elsif(*args); end - def on_embdoc(text); end - def on_embdoc_beg(text); end - def on_embdoc_end(text); end - def on_embexpr_beg(tok); end - def on_embexpr_end(tok); end - def on_embvar(tok); end - def on_ensure(*args); end - def on_excessed_comma(*args); end - def on_fcall(*args); end - def on_field(*args); end - def on_float(tok); end - def on_for(*args); end - def on_gvar(tok); end - def on_hash(*args); end - def on_heredoc_beg(tok); end - def on_heredoc_dedent(*args); end - def on_heredoc_end(tok); end - def on_hshptn(*args); end - def on_ident(tok); end - def on_if(*args); end - def on_if_mod(*args); end - def on_ifop(*args); end - def on_ignored_nl(tok); end - def on_ignored_sp(tok); end - def on_imaginary(tok); end - def on_in(*args); end - def on_int(tok); end - def on_ivar(tok); end - def on_kw(tok); end - def on_kwrest_param(*args); end - def on_label(data); end - def on_label_end(tok); end - def on_lambda(*args); end - def on_lbrace(tok); end - def on_lbracket(tok); end - def on_lparen(tok); end - def on_magic_comment(*args); end - def on_massign(*args); end - def on_method_add_arg(list, item); end - def on_method_add_block(list, item); end - def on_mlhs_add(list, item); end - def on_mlhs_add_post(list, item); end - def on_mlhs_add_star(list, item); end - def on_mlhs_new(*args); end - def on_mlhs_paren(*args); end - def on_module(*args); end - def on_mrhs_add(list, item); end - def on_mrhs_add_star(list, item); end - def on_mrhs_new(*args); end - def on_mrhs_new_from_args(*args); end - def on_next(*args); end - def on_nl(tok); end - def on_nokw_param(*args); end - def on_op(tok); end - def on_opassign(*args); end - def on_operator_ambiguous(*args); end - def on_param_error(*args); end - def on_params(*args); end - def on_paren(*args); end - def on_parse_error(msg); end - def on_period(tok); end - def on_program(*args); end - def on_qsymbols_add(list, item); end - def on_qsymbols_beg(tok); end - def on_qsymbols_new(*args); end - def on_qwords_add(list, item); end - def on_qwords_beg(tok); end - def on_qwords_new(*args); end - def on_rational(tok); end - def on_rbrace(tok); end - def on_rbracket(tok); end - def on_redo(*args); end - def on_regexp_add(list, item); end - def on_regexp_beg(tok); end - def on_regexp_end(tok); end - def on_regexp_literal(*args); end - def on_regexp_new(*args); end - def on_rescue(exc, *args); end - def on_rescue_mod(*args); end - def on_rest_param(*args); end - def on_retry(*args); end - def on_return(*args); end - def on_return0(*args); end - def on_rparen(tok); end - def on_sclass(*args); end - def on_semicolon(tok); end - def on_sp(tok); end - def on_stmts_add(list, item); end - def on_stmts_new(*args); end - def on_string_add(list, item); end - def on_string_concat(*args); end - def on_string_content(*args); end - def on_string_dvar(*args); end - def on_string_embexpr(*args); end - def on_string_literal(*args); end - def on_super(*args); end - def on_symbeg(tok); end - def on_symbol(*args); end - def on_symbol_literal(*args); end - def on_symbols_add(list, item); end - def on_symbols_beg(tok); end - def on_symbols_new(*args); end - def on_tlambda(tok); end - def on_tlambeg(tok); end - def on_top_const_field(*args); end - def on_top_const_ref(*args); end - def on_tstring_beg(tok); end - def on_tstring_content(tok); end - def on_tstring_end(tok); end - def on_unary(op, val); end - def on_undef(*args); end - def on_unless(*args); end - def on_unless_mod(*args); end - def on_until(*args); end - def on_until_mod(*args); end - def on_var_alias(*args); end - def on_var_field(*args); end - def on_var_ref(*args); end - def on_vcall(*args); end - def on_void_stmt; end - def on_when(*args); end - def on_while(*args); end - def on_while_mod(*args); end - def on_word_add(list, item); end - def on_word_new(*args); end - def on_words_add(list, item); end - def on_words_beg(tok); end - def on_words_new(*args); end - def on_words_sep(tok); end - def on_xstring_add(list, item); end - def on_xstring_literal(*args); end - def on_xstring_new(*args); end - def on_yield(*args); end - def on_yield0(*args); end - def on_zsuper(*args); end - def parse; end - def root; end - def shebang_line; end - def tokens; end - def visit_event(node); end - def visit_event_arr(node); end - def visit_ns_token(token, data, ast_token = nil); end -end -class YARD::Parser::Ruby::Legacy::RubyParser < YARD::Parser::Base - def encoding_line; end - def enumerator; end - def initialize(source, _filename); end - def parse; end - def shebang_line; end - def tokenize; end -end -class YARD::Parser::C::CParser < YARD::Parser::Base - def advance(num = nil); end - def advance_loop; end - def attach_comment(statement); end - def back(num = nil); end - def char(num = nil); end - def consume_body_statements; end - def consume_comment(add_comment = nil); end - def consume_directive; end - def consume_quote(type = nil); end - def consume_toplevel_statement; end - def consume_until(end_char, bracket_level = nil, brace_level = nil, add_comment = nil); end - def consume_whitespace; end - def enumerator; end - def initialize(source, file = nil); end - def nextchar(num = nil); end - def nextline; end - def parse; end - def parse_toplevel; end - def prevchar(num = nil); end - def strip_non_statement_data; end - def struct; end - def tokenize; end -end -class YARD::Parser::UndocumentableError < RuntimeError -end -class YARD::Parser::ParserSyntaxError < YARD::Parser::UndocumentableError -end -class YARD::Parser::OrderedParser - def files; end - def files=(arg0); end - def initialize(global_state, files); end - def parse; end -end -class YARD::Parser::SourceParser - def contents; end - def convert_encoding(content); end - def file; end - def file=(arg0); end - def globals; end - def initialize(parser_type = nil, globals1 = nil, globals2 = nil); end - def parse(content = nil); end - def parser_class; end - def parser_type; end - def parser_type=(value); end - def parser_type_for_filename(filename); end - def post_process; end - def self.after_parse_file(&block); end - def self.after_parse_file_callbacks; end - def self.after_parse_list(&block); end - def self.after_parse_list_callbacks; end - def self.before_parse_file(&block); end - def self.before_parse_file_callbacks; end - def self.before_parse_list(&block); end - def self.before_parse_list_callbacks; end - def self.parse(paths = nil, excluded = nil, level = nil); end - def self.parse_in_order(*files); end - def self.parse_string(content, ptype = nil); end - def self.parser_type; end - def self.parser_type=(value); end - def self.parser_type_extensions; end - def self.parser_type_extensions=(value); end - def self.parser_type_for_extension(extension); end - def self.parser_types; end - def self.parser_types=(value); end - def self.register_parser_type(type, parser_klass, extensions = nil); end - def self.tokenize(content, ptype = nil); end - def self.validated_parser_type(type); end - def tokenize(content); end -end -class YARD::Handlers::HandlerAborted < RuntimeError -end -class YARD::Handlers::NamespaceMissingError < YARD::Parser::UndocumentableError - def initialize(object); end - def object; end - def object=(arg0); end -end -class YARD::Handlers::Base - def abort!; end - def call_params; end - def caller_method; end - def ensure_loaded!(object, max_retries = nil); end - def extra_state; end - def globals; end - def initialize(source_parser, stmt); end - def namespace; end - def namespace=(v); end - def owner; end - def owner=(v); end - def parse_block(*arg0); end - def parser; end - def process; end - def push_state(opts = nil); end - def register(*objects); end - def register_docstring(object, docstring = nil, stmt = nil); end - def register_dynamic(object); end - def register_ensure_loaded(object); end - def register_file_info(object, file = nil, line = nil, comments = nil); end - def register_group(object, group = nil); end - def register_module_function(object); end - def register_source(object, source = nil, type = nil); end - def register_transitive_tags(object); end - def register_visibility(object, visibility = nil); end - def scope; end - def scope=(v); end - def self.clear_subclasses; end - def self.handlers; end - def self.handles(*matches); end - def self.handles?(statement); end - def self.in_file(filename); end - def self.inherited(subclass); end - def self.matches_file?(filename); end - def self.namespace_only; end - def self.namespace_only?; end - def self.process(&block); end - def self.subclasses; end - def statement; end - def visibility; end - def visibility=(v); end - include YARD::CodeObjects - include YARD::Parser -end -class YARD::Handlers::Ruby::HandlesExtension - def initialize(name); end - def matches?(node); end - def name; end -end -class YARD::Handlers::Ruby::MethodCallWrapper < YARD::Handlers::Ruby::HandlesExtension - def matches?(node); end -end -class YARD::Handlers::Ruby::TestNodeWrapper < YARD::Handlers::Ruby::HandlesExtension - def matches?(node); end -end -class YARD::Handlers::Ruby::Base < YARD::Handlers::Base - def call_params; end - def caller_method; end - def parse_block(inner_node, opts = nil); end - def self.handles?(node); end - def self.meta_type(type); end - def self.method_call(name = nil); end - include YARD::Parser::Ruby -end -module YARD::Handlers::Ruby::StructHandlerMethods - def add_reader_tags(klass, new_method, member); end - def add_writer_tags(klass, new_method, member); end - def create_attributes(klass, members); end - def create_class(classname, superclass); end - def create_member_method?(klass, member, type = nil); end - def create_reader(klass, member); end - def create_writer(klass, member); end - def member_tag_for_member(klass, member, type = nil); end - def members_from_tags(klass); end - def return_type_from_tag(member_tag); end - include YARD::CodeObjects -end -class YARD::Handlers::Ruby::ClassHandler < YARD::Handlers::Ruby::Base - def create_struct_superclass(superclass, superclass_def); end - def extract_parameters(superclass); end - def parse_struct_superclass(klass, superclass); end - def parse_superclass(superclass); end - def struct_superclass_name(superclass); end - include Anonymous_Module_6 - include YARD::Handlers::Ruby::StructHandlerMethods -end -module Anonymous_Module_6 - def process; end -end -module YARD::CodeObjects::NamespaceMapper - def clear_separators; end - def default_separator(value = nil); end - def register_separator(sep, *valid_types); end - def self.default_separator; end - def self.default_separator=(arg0); end - def self.invalidate; end - def self.map; end - def self.map_match; end - def self.on_invalidate(&block); end - def self.rev_map; end - def separators; end - def separators_for_type(type); end - def separators_match; end - def types_for_separator(sep); end - def unregister_separator_by_type(type); end -end -class YARD::CodeObjects::CodeObjectList < Array - def <<(value); end - def initialize(owner = nil); end - def push(value); end -end -class YARD::CodeObjects::Base - def ==(other); end - def [](key); end - def []=(key, value); end - def add_file(file, line = nil, has_comments = nil); end - def add_tag(*tags); end - def base_docstring; end - def copy_to(other); end - def copyable_attributes; end - def docstring(locale = nil); end - def docstring=(comments); end - def dynamic; end - def dynamic=(arg0); end - def dynamic?; end - def eql?(other); end - def equal?(other); end - def file; end - def files; end - def format(options = nil); end - def format_source(source); end - def group; end - def group=(arg0); end - def has_tag?(name); end - def hash; end - def initialize(namespace, name, *arg2); end - def inspect; end - def line; end - def method_missing(meth, *args, &block); end - def name(prefix = nil); end - def namespace; end - def namespace=(obj); end - def parent; end - def parent=(obj); end - def path; end - def relative_path(other); end - def root?; end - def self.===(other); end - def self.new(namespace, name, *args, &block); end - def sep; end - def signature; end - def signature=(arg0); end - def source; end - def source=(statement); end - def source_type; end - def source_type=(arg0); end - def tag(name); end - def tags(name = nil); end - def title; end - def to_ary; end - def to_s; end - def translate_docstring(locale); end - def type; end - def visibility; end - def visibility=(v); end -end -class YARD::CodeObjects::MethodObject < YARD::CodeObjects::Base - def aliases; end - def attr_info; end - def constructor?; end - def copyable_attributes; end - def explicit; end - def explicit=(arg0); end - def initialize(namespace, name, scope = nil, &block); end - def is_alias?; end - def is_attribute?; end - def is_explicit?; end - def module_function?; end - def name(prefix = nil); end - def overridden_method; end - def parameters; end - def parameters=(arg0); end - def path; end - def reader?; end - def scope; end - def scope=(v); end - def sep; end - def writer?; end -end -class YARD::DocstringParser - def call_after_parse_callbacks; end - def call_directives_after_parse; end - def create_directive(tag_name, tag_buf); end - def create_ref_tag(tag_name, name, object_name); end - def create_tag(tag_name, tag_buf = nil); end - def detect_reference(content); end - def directives; end - def directives=(arg0); end - def handler; end - def handler=(arg0); end - def initialize(library = nil); end - def library; end - def library=(arg0); end - def namespace; end - def object; end - def object=(arg0); end - def parse(content, object = nil, handler = nil); end - def parse_content(content); end - def post_process; end - def raw_text; end - def raw_text=(arg0); end - def reference; end - def reference=(arg0); end - def self.after_parse(&block); end - def self.after_parse_callbacks; end - def state; end - def state=(arg0); end - def tag_is_directive?(tag_name); end - def tags; end - def tags=(arg0); end - def text; end - def text=(arg0); end - def to_docstring; end -end -class YARD::Docstring < String - def +(other); end - def add_tag(*tags); end - def all; end - def all=(content, parse = nil); end - def blank?(only_visible_tags = nil); end - def convert_ref_tags; end - def delete_tag_if(&block); end - def delete_tags(name); end - def dup; end - def has_tag?(name); end - def hash_flag; end - def hash_flag=(v); end - def initialize(content = nil, object = nil); end - def line; end - def line_range; end - def line_range=(arg0); end - def object; end - def object=(arg0); end - def parse_comments(comments); end - def ref_tags; end - def replace(content, parse = nil); end - def resolve_reference; end - def self.default_parser; end - def self.default_parser=(arg0); end - def self.new!(text, tags = nil, object = nil, raw_data = nil, ref_object = nil); end - def self.parser(*args); end - def stable_sort_by(list); end - def summary; end - def tag(name); end - def tags(name = nil); end - def to_raw; end - def to_s; end -end -module YARD::Registry - def self.[](path); end - def self.all(*types); end - def self.at(path); end - def self.checksum_for(data); end - def self.checksums; end - def self.clear; end - def self.delete(object); end - def self.delete_from_disk; end - def self.each(&block); end - def self.global_yardoc_file(spec, for_writing = nil); end - def self.instance; end - def self.load!(file = nil); end - def self.load(files = nil, reparse = nil); end - def self.load_all; end - def self.load_yardoc(file = nil); end - def self.local_yardoc_file(spec, for_writing = nil); end - def self.locale(name); end - def self.lock_for_writing(file = nil, &block); end - def self.locked_for_writing?(file = nil); end - def self.old_global_yardoc_file(spec, for_writing = nil); end - def self.partial_resolve(namespace, name, type = nil); end - def self.paths(reload = nil); end - def self.po_dir; end - def self.po_dir=(dir); end - def self.proxy_types; end - def self.register(object); end - def self.resolve(namespace, name, inheritance = nil, proxy_fallback = nil, type = nil); end - def self.root; end - def self.save(merge = nil, file = nil); end - def self.single_object_db; end - def self.single_object_db=(v); end - def self.thread_local_resolver; end - def self.thread_local_store; end - def self.thread_local_store=(value); end - def self.yardoc_file; end - def self.yardoc_file=(v); end - def self.yardoc_file_for_gem(gem, ver_require = nil, for_writing = nil); end - extend Enumerable -end -class YARD::Tags::Tag - def explain_types; end - def initialize(tag_name, text, types = nil, name = nil); end - def name; end - def name=(arg0); end - def object; end - def object=(arg0); end - def tag_name; end - def tag_name=(arg0); end - def text; end - def text=(arg0); end - def type; end - def types; end - def types=(arg0); end -end -class YARD::Tags::OverloadTag < YARD::Tags::Tag - def docstring; end - def has_tag?(name); end - def initialize(tag_name, text); end - def is_a?(other); end - def kind_of?(other); end - def method_missing(*args, &block); end - def name(prefix = nil); end - def object=(value); end - def parameters; end - def parse_signature; end - def parse_tag(text); end - def signature; end - def tag(name); end - def tags(name = nil); end - def type; end -end -class YARD::Tags::Directive - def after_parse; end - def call; end - def expanded_text; end - def expanded_text=(arg0); end - def handler; end - def initialize(tag, parser); end - def inside_directive?; end - def object; end - def parser; end - def parser=(arg0); end - def tag; end - def tag=(arg0); end -end -class YARD::Tags::EndGroupDirective < YARD::Tags::Directive - def call; end -end -class YARD::Tags::GroupDirective < YARD::Tags::Directive - def call; end -end -class YARD::Tags::MacroDirective < YARD::Tags::Directive - def anonymous?; end - def attach?; end - def call; end - def class_method?; end - def expand(macro_data); end - def find_or_create; end - def new?; end - def warn; end -end -class YARD::Tags::MethodDirective < YARD::Tags::Directive - def after_parse; end - def call; end - def create_object; end - def method_name; end - def method_signature; end - def sanitized_tag_signature; end - def use_indented_text; end -end -class YARD::Tags::AttributeDirective < YARD::Tags::MethodDirective - def after_parse; end - def create_attribute_data(object); end - def method_name; end - def method_signature; end - def readable?; end - def writable?; end -end -class YARD::Tags::ParseDirective < YARD::Tags::Directive - def call; end -end -class YARD::Tags::ScopeDirective < YARD::Tags::Directive - def call; end -end -class YARD::Tags::VisibilityDirective < YARD::Tags::Directive - def call; end -end -class YARD::Tags::Library - def abstract_tag(text); end - def api_tag(text); end - def attr_reader_tag(text); end - def attr_tag(text); end - def attr_writer_tag(text); end - def attribute_directive(tag, parser); end - def author_tag(text); end - def deprecated_tag(text); end - def directive_call(tag, parser); end - def directive_create(tag_name, tag_buf, parser); end - def endgroup_directive(tag, parser); end - def example_tag(text); end - def factory; end - def factory=(arg0); end - def group_directive(tag, parser); end - def has_directive?(tag_name); end - def has_tag?(tag_name); end - def initialize(factory = nil); end - def macro_directive(tag, parser); end - def method_directive(tag, parser); end - def note_tag(text); end - def option_tag(text); end - def overload_tag(text); end - def param_tag(text); end - def parse_directive(tag, parser); end - def private_tag(text); end - def raise_tag(text); end - def return_tag(text); end - def scope_directive(tag, parser); end - def see_tag(text); end - def self.default_factory; end - def self.default_factory=(factory); end - def self.define_directive(tag, tag_meth = nil, directive_class = nil); end - def self.define_tag(label, tag, meth = nil); end - def self.directive_method_name(tag_name); end - def self.factory_method_for(tag); end - def self.factory_method_for_directive(directive); end - def self.instance; end - def self.labels; end - def self.sorted_labels; end - def self.tag_method_name(tag_name); end - def self.tag_or_directive_method_name(tag_name, type = nil); end - def self.transitive_tags; end - def self.transitive_tags=(arg0); end - def self.visible_tags; end - def self.visible_tags=(arg0); end - def send_to_factory(tag_name, meth, text); end - def since_tag(text); end - def tag_create(tag_name, tag_buf); end - def todo_tag(text); end - def version_tag(text); end - def visibility_directive(tag, parser); end - def yield_tag(text); end - def yieldparam_tag(text); end - def yieldreturn_tag(text); end -end -class YARD::Handlers::Ruby::MixinHandler < YARD::Handlers::Ruby::Base - def process_mixin(mixin); end - def recipient(*args, &blk); end - include Anonymous_Module_7 -end -module Anonymous_Module_7 - def process; end -end diff --git a/sorbet/rbi/gems/yard@0.9.28.rbi b/sorbet/rbi/gems/yard@0.9.28.rbi new file mode 100644 index 00000000..f4c5399a --- /dev/null +++ b/sorbet/rbi/gems/yard@0.9.28.rbi @@ -0,0 +1,17582 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `yard` gem. +# Please instead update this file by running `bin/tapioca gem yard`. + +# source://yard-0.9.28/lib/yard.rb:62 +::RUBY19 = T.let(T.unsafe(nil), TrueClass) + +# source://yard-0.9.28/lib/yard/core_ext/array.rb:2 +class Array + include ::Enumerable + + # Places values before or after another object (by value) in + # an array. This is used in tandem with the before and after + # methods of the {Insertion} class. + # + # @example Places an item before another + # [1, 2, 3].place(4).before(3) # => [1, 2, 4, 3] + # @example Places an item after another + # [:a, :b, :c].place(:x).after(:a) # => [:a, :x, :b, :c] + # @param values [Array] value to insert + # @return [Insertion] an insertion object to + # @see Insertion#before + # @see Insertion#after + # + # source://yard-0.9.28/lib/yard/core_ext/array.rb:15 + def place(*values); end +end + +# source://yard-0.9.28/lib/yard/core_ext/file.rb:4 +class File < ::IO + class << self + # Cleans a path by removing extraneous '..', '.' and '/' characters + # + # @example Clean a path + # File.cleanpath('a/b//./c/../e') # => "a/b/e" + # @param path [String] the path to clean + # @param rel_root [Boolean] allows relative path above root value + # @return [String] the sanitized path + # + # source://yard-0.9.28/lib/yard/core_ext/file.rb:37 + def cleanpath(path, rel_root = T.unsafe(nil)); end + + # Forces opening a file (for writing) by first creating the file's directory + # + # @param file [String] the filename to open + # @since 0.5.2 + # + # source://yard-0.9.28/lib/yard/core_ext/file.rb:57 + def open!(file, *args, &block); end + + # Reads a file with binary encoding + # + # @return [String] the ascii-8bit encoded data + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/core_ext/file.rb:66 + def read_binary(file); end + + # Turns a path +to+ into a relative path from starting + # point +from+. The argument +from+ is assumed to be + # a filename. To treat it as a directory, make sure it + # ends in +File::SEPARATOR+ ('/' on UNIX filesystems). + # + # @param from [String] the starting filename + # (or directory with +from_isdir+ set to +true+). + # @param to [String] the final path that should be made relative. + # @return [String] the relative path from +from+ to +to+. + # + # source://yard-0.9.28/lib/yard/core_ext/file.rb:19 + def relative_path(from, to); end + end +end + +# source://yard-0.9.28/lib/yard/core_ext/file.rb:5 +File::RELATIVE_PARENTDIR = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/core_ext/file.rb:6 +File::RELATIVE_SAMEDIR = T.let(T.unsafe(nil), String) + +# :stopdoc: +# +# source://yard-0.9.28/lib/yard/rubygems/backports/gem.rb:2 +module Gem + class << self + # Returns the Gem::SourceIndex of specifications that are in the Gem.path + # + # source://yard-0.9.28/lib/yard/rubygems/backports/gem.rb:6 + def source_index; end + end +end + +# Cache is an alias for SourceIndex to allow older YAMLized source index +# objects to load properly. +# +# source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:363 +Gem::Cache = Gem::SourceIndex + +# source://RUBY_ROOT/rubygems/compatibility.rb:30 +Gem::ConfigMap = T.let(T.unsafe(nil), Hash) + +# source://RUBY_ROOT/rubygems/compatibility.rb:18 +Gem::RbConfigPriorities = T.let(T.unsafe(nil), Array) + +# source://RUBY_ROOT/rubygems/compatibility.rb:15 +Gem::RubyGemsVersion = T.let(T.unsafe(nil), String) + +# The SourceIndex object indexes all the gems available from a +# particular source (e.g. a list of gem directories, or a remote +# source). A SourceIndex maps a gem full name to a gem +# specification. +# +# NOTE:: The class used to be named Cache, but that became +# confusing when cached source fetchers where introduced. The +# constant Gem::Cache is an alias for this class to allow old +# YAMLized source index objects to load properly. +# +# source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:21 +class Gem::SourceIndex + include ::Enumerable + + # Constructs a source index instance from the provided specifications, which + # is a Hash of gem full names and Gem::Specifications. + # -- + # TODO merge @gems and @prerelease_gems and provide a separate method + # #prerelease_gems + # + # @return [SourceIndex] a new instance of SourceIndex + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:102 + def initialize(specifications = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:348 + def ==(other); end + + # Add a gem specification to the source index. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:193 + def add_spec(gem_spec, name = T.unsafe(nil)); end + + # Add gem specifications to the source index. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:202 + def add_specs(*gem_specs); end + + # TODO: remove method + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:109 + def all_gems; end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:352 + def dump; end + + # Iterate over the specifications in the source index. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:218 + def each(&block); end + + # Find a gem by an exact match on the short name. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:256 + def find_name(gem_name, requirement = T.unsafe(nil)); end + + # The signature for the given gem specification. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:242 + def gem_signature(gem_full_name); end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:34 + def gems; end + + # The signature for the source index. Changes in the signature indicate a + # change in the index. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:233 + def index_signature; end + + # Returns an Array specifications for the latest released versions + # of each gem in this index. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:143 + def latest_specs(include_prerelease = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:248 + def length; end + + # Reconstruct the source index from the specifications in +spec_dirs+. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:124 + def load_gems_in(*spec_dirs); end + + # Returns an Array of Gem::Specifications that are not up to date. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:330 + def outdated; end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:113 + def prerelease_gems; end + + # An array including only the prerelease gemspecs + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:179 + def prerelease_specs; end + + # Replaces the gems in the source index from specifications in the + # directories this source index was created from. Raises an exception if + # this source index wasn't created from a directory (via from_gems_in or + # from_installed_gems, or having spec_dirs set). + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:322 + def refresh!; end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:117 + def released_gems; end + + # An array including only the released gemspecs + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:186 + def released_specs; end + + # Remove a gem specification named +full_name+. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:211 + def remove_spec(full_name); end + + # Search for a gem by Gem::Dependency +gem_pattern+. If +only_platform+ + # is true, only gems matching Gem::Platform.local will be returned. An + # Array of matching Gem::Specification objects is returned. + # + # For backwards compatibility, a String or Regexp pattern may be passed as + # +gem_pattern+, and a Gem::Requirement for +platform_only+. This + # behavior is deprecated and will be removed. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:270 + def search(gem_pattern, platform_only = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:248 + def size; end + + # Directories to use to refresh this SourceIndex when calling refresh! + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:39 + def spec_dirs; end + + # Directories to use to refresh this SourceIndex when calling refresh! + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:39 + def spec_dirs=(_arg0); end + + # The gem specification given a full gem spec name. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:225 + def specification(full_name); end + + class << self + # Creates a new SourceIndex from the ruby format gem specifications in + # +spec_dirs+. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:80 + def from_gems_in(*spec_dirs); end + + # Factory method to construct a source index instance for a given + # path. + # + # deprecated:: + # If supplied, from_installed_gems will act just like + # +from_gems_in+. This argument is deprecated and is provided + # just for backwards compatibility, and should not generally + # be used. + # + # return:: + # SourceIndex instance + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:61 + def from_installed_gems(*deprecated); end + + # Returns a list of directories from Gem.path that contain specifications. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:72 + def installed_spec_directories; end + + # Loads a ruby-format specification from +file_name+ and returns the + # loaded spec. + # + # source://yard-0.9.28/lib/yard/rubygems/backports/source_index.rb:90 + def load_specification(file_name); end + end +end + +# source://RUBY_ROOT/rubygems.rb:121 +Gem::UNTAINT = T.let(T.unsafe(nil), Proc) + +# source://RUBY_ROOT/rubygems/exceptions.rb:292 +Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:17 +class IRB::SLex + # @return [SLex] a new instance of SLex + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:25 + def initialize; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:60 + def create(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:29 + def def_rule(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil), &block); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:36 + def def_rules(*tokens, &block); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:77 + def inspect; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:64 + def match(token); end + + # need a check? + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:51 + def postproc(token); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:45 + def preproc(token, proc); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:56 + def search(token); end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:18 +IRB::SLex::DOUT = T.let(T.unsafe(nil), IRB::Notifier::CompositeNotifier) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:20 +IRB::SLex::D_DEBUG = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:21 +IRB::SLex::D_DETAIL = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:19 +IRB::SLex::D_WARN = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier) + +# ---------------------------------------------------------------------- +# +# class Node - +# +# ---------------------------------------------------------------------- +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:86 +class IRB::SLex::Node + # if postproc is nil, this node is an abstract node. + # if postproc is non-nil, this node is a real node. + # + # @return [Node] a new instance of Node + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:89 + def initialize(preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:113 + def create_subnode(chrs, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end + + # chrs: String + # character array + # io must have getc()/ungetc(); and ungetc() must be + # able to be called arbitrary number of times. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:161 + def match(chrs, op = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:198 + def match_io(io, op = T.unsafe(nil)); end + + # Returns the value of attribute postproc. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:96 + def postproc; end + + # Sets the attribute postproc + # + # @param value the value to set the attribute postproc to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:96 + def postproc=(_arg0); end + + # Returns the value of attribute preproc. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:95 + def preproc; end + + # Sets the attribute preproc + # + # @param value the value to set the attribute preproc to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:95 + def preproc=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/irb/slex.rb:98 + def search(chrs, opt = T.unsafe(nil)); end +end + +# The Insertion class inserts a value before or after another +# value in a list. +# +# @example +# Insertion.new([1, 2, 3], 4).before(3) # => [1, 2, 4, 3] +# +# source://yard-0.9.28/lib/yard/core_ext/insertion.rb:7 +class Insertion + # Creates an insertion object on a list with a value to be + # inserted. To finalize the insertion, call {#before} or + # {#after} on the object. + # + # @param list [Array] the list to perform the insertion on + # @param value [Object] the value to insert + # @return [Insertion] a new instance of Insertion + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:14 + def initialize(list, value); end + + # Inserts the value after +val+. + # + # @example If subsections are ignored + # Insertion.new([1, [2], 3], :X).after(1) # => [1, [2], :X, 3] + # @param val [Object] the object the value will be inserted after + # @param recursive [Boolean] look inside sublists + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:30 + def after(val, recursive = T.unsafe(nil)); end + + # Alias for {#after} with +recursive+ set to true + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:38 + def after_any(val); end + + # Inserts the value before +val+ + # + # @param val [Object] the object the value will be inserted before + # @param recursive [Boolean] look inside sublists + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:22 + def before(val, recursive = T.unsafe(nil)); end + + # Alias for {#before} with +recursive+ set to true + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:34 + def before_any(val); end + + private + + # This method performs the actual insertion + # + # @param val [Object] the value to insert + # @param rel [Fixnum] the relative index (0 or 1) of where the object + # should be placed + # @param recursive [Boolean] look inside sublists + # @param list [Array] the list to place objects into + # + # source://yard-0.9.28/lib/yard/core_ext/insertion.rb:49 + def insertion(val, rel, recursive = T.unsafe(nil), list = T.unsafe(nil)); end +end + +# We need to do the alias-method-chain dance since Bootsnap does the same, +# and prepended modules and alias-method-chain don't play well together. +# +# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked! +# That's because RubyGems does alias-method-chain for Kernel#require and such, +# so, if Bootsnap were to do prepend, it might end up breaking RubyGems. +# +# source://yard-0.9.28/lib/yard/core_ext/module.rb:2 +class Module + # Returns the class name of a full module namespace path + # + # @example + # module A::B::C; class_name end # => "C" + # @return [String] the last part of a module path + # + # source://yard-0.9.28/lib/yard/core_ext/module.rb:8 + def class_name; end +end + +class Object < ::BasicObject + include ::Kernel + + private + + # source://yard-0.9.28/lib/yard/globals.rb:8 + def P(namespace, name = T.unsafe(nil), type = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/globals.rb:20 + def log; end +end + +# source://yard-0.9.28/lib/yard.rb:62 +RUBY19 = T.let(T.unsafe(nil), TrueClass) + +# Extensions to the core String class +# +# source://yard-0.9.28/lib/yard/core_ext/string.rb:2 +class String + include ::Comparable + + # Splits text into tokens the way a shell would, handling quoted + # text as a single token. Use '\"' and "\'" to escape quotes and + # '\\' to escape a backslash. + # + # @return [Array] an array representing the tokens + # + # source://yard-0.9.28/lib/yard/core_ext/string.rb:8 + def shell_split; end +end + +# A subclass of Hash where all keys are converted into Symbols, and +# optionally, all String values are converted into Symbols. +# +# source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:8 +class SymbolHash < ::Hash + # Creates a new SymbolHash object + # + # @param symbolize_value [Boolean] converts any String values into Symbols + # if this is set to +true+. + # @return [SymbolHash] a new instance of SymbolHash + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:9 + def initialize(symbolize_value = T.unsafe(nil)); end + + # Accessed a symbolized key + # + # @param key [#to_sym] the key to access + # @return [Object] the value associated with the key + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:49 + def [](key); end + + # Assigns a value to a symbolized key + # + # @param key [#to_sym] the key + # @param value [Object] the value to be assigned. If this is a String and + # values are set to be symbolized, it will be converted into a Symbol. + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:42 + def []=(key, value); end + + # Deleted a key and value associated with it + # + # @param key [#to_sym] the key to delete + # @return [void] + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:54 + def delete(key); end + + # Tests if a symbolized key exists + # + # @param key [#to_sym] the key to test + # @return [Boolean] whether the key exists + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:59 + def has_key?(key); end + + # Tests if a symbolized key exists + # + # @param key [#to_sym] the key to test + # @return [Boolean] whether the key exists + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:59 + def key?(key); end + + # Merges the contents of another hash into a new SymbolHash object + # + # @param hash [Hash] the hash of objects to copy + # @return [SymbolHash] a new SymbolHash containing the merged data + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:74 + def merge(hash); end + + # Updates the object with the contents of another Hash object. + # This method modifies the original SymbolHash object + # + # @param hash [Hash] the hash object to copy the values from + # @return [SymbolHash] self + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:67 + def merge!(hash); end + + # Updates the object with the contents of another Hash object. + # This method modifies the original SymbolHash object + # + # @param hash [Hash] the hash object to copy the values from + # @return [SymbolHash] self + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:67 + def update(hash); end + + class << self + # @overload [] + # @overload [] + # + # source://yard-0.9.28/lib/yard/core_ext/symbol_hash.rb:28 + def [](*hsh); end + end +end + +# @private +# +# source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:42 +class WEBrick::HTTPRequest + # Returns the value of attribute version_supplied. + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:43 + def version_supplied; end + + # Sets the attribute version_supplied + # + # @param value the value to set the attribute version_supplied to. + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:43 + def version_supplied=(_arg0); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:44 + def xhr?; end +end + +# same as Mongrel, Thin and Puma +# +# source://webrick-1.7.0/lib/webrick/httprequest.rb:449 +WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer) + +# Backward compatibility for gem specification lookup +# +# @see Gem::SourceIndex +# +# source://yard-0.9.28/lib/yard.rb:2 +module YARD + class << self + # Loads gems that match the name 'yard-*' (recommended) or 'yard_*' except + # those listed in +~/.yard/ignored_plugins+. This is called immediately + # after YARD is loaded to allow plugin support. + # + # @deprecated Use {Config.load_plugins} + # @return [Boolean] true if all plugins loaded successfully, false otherwise. + # + # source://yard-0.9.28/lib/yard.rb:31 + def load_plugins; end + + # An alias to {Parser::SourceParser}'s parsing method + # + # @example Parse a glob of files + # YARD.parse('lib/**/*.rb') + # @see Parser::SourceParser.parse + # + # source://yard-0.9.28/lib/yard.rb:20 + def parse(*args); end + + # An alias to {Parser::SourceParser}'s parsing method + # + # @example Parse a string of input + # YARD.parse_string('class Foo; end') + # @see Parser::SourceParser.parse_string + # + # source://yard-0.9.28/lib/yard.rb:27 + def parse_string(*args); end + + # @return [Boolean] whether YARD is being run in Ruby 1.8 mode + # + # source://yard-0.9.28/lib/yard.rb:44 + def ruby18?; end + + # @return [Boolean] whether YARD is being run in Ruby 1.9 mode + # + # source://yard-0.9.28/lib/yard.rb:47 + def ruby19?; end + + # @return [Boolean] whether YARD is being run in Ruby 2.0 + # + # source://yard-0.9.28/lib/yard.rb:50 + def ruby2?; end + + # @return [Boolean] whether YARD is being run in Ruby 3.1 + # + # source://yard-0.9.28/lib/yard.rb:56 + def ruby31?; end + + # @return [Boolean] whether YARD is being run in Ruby 3.0 + # + # source://yard-0.9.28/lib/yard.rb:53 + def ruby3?; end + + # @return [Boolean] whether YARD is being run inside of Windows + # + # source://yard-0.9.28/lib/yard.rb:34 + def windows?; end + end +end + +# Namespace for command-line interface components +# +# source://yard-0.9.28/lib/yard/autoload.rb:6 +module YARD::CLI; end + +# Abstract base class for CLI utilities. Provides some helper methods for +# the option parser +# +# @abstract +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/command.rb:11 +class YARD::CLI::Command + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:16 + def description; end + + protected + + # Adds a set of common options to the tail of the OptionParser + # + # @param opts [OptionParser] the option parser object + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:24 + def common_options(opts); end + + # Loads a Ruby script. If <tt>Config.options[:safe_mode]</tt> is enabled, + # this method will do nothing. + # + # @param file [String] the path to the script to load + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:68 + def load_script(file); end + + # Parses the option and gracefully handles invalid switches + # + # @param opts [OptionParser] the option parser object + # @param args [Array<String>] the arguments passed from input. This + # array will be modified. + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:55 + def parse_options(opts, args); end + + # Callback when an unrecognize option is parsed + # + # @param err [OptionParser::ParseError] the exception raised by the + # option parser + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:80 + def unrecognized_option(err); end + + class << self + # Helper method to run the utility on an instance. + # + # @see #run + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/command.rb:14 + def run(*args); end + end +end + +# This class parses a command name out of the +yard+ CLI command and calls +# that command in the form: +# +# $ yard command_name [options] +# +# If no command or arguments are specified, or if the arguments immediately +# begin with a +--opt+ (not +--help+), the {default_command} will be used +# (which itself defaults to +:doc+). +# +# == Adding a Command +# +# To add a custom command via plugin, create a mapping in {commands} from +# the Symbolic command name to the {Command} class that implements the +# command. To implement a command, see the documentation for the {Command} +# class. +# +# @see Command +# @see commands +# @see default_command +# +# source://yard-0.9.28/lib/yard/cli/command_parser.rb:23 +class YARD::CLI::CommandParser + # @return [CommandParser] a new instance of CommandParser + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:56 + def initialize; end + + # Runs the {Command} object matching the command name of the first + # argument. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:63 + def run(*args); end + + private + + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:80 + def commands; end + + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:82 + def list_commands; end + + class << self + # @return [Hash{Symbol => Command}] the mapping of command names to + # command classes to parse the user command. + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:27 + def commands; end + + # @return [Hash{Symbol => Command}] the mapping of command names to + # command classes to parse the user command. + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:27 + def commands=(_arg0); end + + # @return [Symbol] the default command name to use when no options + # are specified or + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:31 + def default_command; end + + # @return [Symbol] the default command name to use when no options + # are specified or + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:31 + def default_command=(_arg0); end + + # Convenience method to create a new CommandParser and call {#run} + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/command_parser.rb:54 + def run(*args); end + end +end + +# CLI command to view or edit configuration options +# +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/cli/config.rb:7 +class YARD::CLI::Config < ::YARD::CLI::Command + # @return [Config] a new instance of Config + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:26 + def initialize; end + + # @return [Boolean] whether to append values to existing key + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:20 + def append; end + + # @return [Boolean] whether to append values to existing key + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:20 + def append=(_arg0); end + + # @return [Boolean] whether the value being set should be inside a list + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:17 + def as_list; end + + # @return [Boolean] whether the value being set should be inside a list + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:17 + def as_list=(_arg0); end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:36 + def description; end + + # @return [String, nil] command to use when configuring ~/.gemrc file. + # If the string is nil, configuration should not occur. + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:24 + def gem_install_cmd; end + + # @return [String, nil] command to use when configuring ~/.gemrc file. + # If the string is nil, configuration should not occur. + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:24 + def gem_install_cmd=(_arg0); end + + # @return [Symbol, nil] the key to view/edit, if any + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:8 + def key; end + + # @return [Symbol, nil] the key to view/edit, if any + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:8 + def key=(_arg0); end + + # @return [Boolean] whether to reset the {#key} + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:14 + def reset; end + + # @return [Boolean] whether to reset the {#key} + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:14 + def reset=(_arg0); end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:40 + def run(*args); end + + # @return [Array, nil] the list of values to set (or single value), if modifying + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:11 + def values; end + + # @return [Array, nil] the list of values to set (or single value), if modifying + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:11 + def values=(_arg0); end + + private + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:57 + def configure_gemrc; end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:111 + def encode_value(value); end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:103 + def encode_values; end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:97 + def list_configuration; end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:78 + def modify_item; end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:120 + def optparse(*args); end + + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/config.rb:92 + def view_item; end +end + +# CLI command to return the objects that were added/removed from 2 versions +# of a project (library, gem, working copy). +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/diff.rb:11 +class YARD::CLI::Diff < ::YARD::CLI::Command + # @return [Diff] a new instance of Diff + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:12 + def initialize; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:24 + def description; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:28 + def run(*args); end + + private + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:83 + def added_objects(registry1, registry2); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:78 + def all_objects; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:233 + def cleanup(gemfile); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:175 + def expand_and_parse(gemfile, io); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:187 + def expand_gem(gemfile, io); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:181 + def generate_yardoc(dir); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:118 + def load_gem_data(gemfile); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:102 + def load_git_commit(commit); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:87 + def modified_objects(registry1, registry2); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:239 + def optparse(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:98 + def removed_objects(registry1, registry2); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/diff.rb:225 + def require_rubygems; end +end + +# Display one object +# +# @since 0.8.6 +# +# source://yard-0.9.28/lib/yard/cli/display.rb:6 +class YARD::CLI::Display < ::YARD::CLI::Yardoc + # @return [Display] a new instance of Display + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:9 + def initialize(*args); end + + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:7 + def description; end + + # @return [String] the output data for all formatted objects + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:27 + def format_objects; end + + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:61 + def output_options(opts); end + + # Parses commandline options. + # + # @param args [Array<String>] each tokenized argument + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:46 + def parse_arguments(*args); end + + # Runs the commandline utility, parsing arguments and displaying an object + # from the {Registry}. + # + # @param args [Array<String>] the list of arguments. + # @return [void] + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:21 + def run(*args); end + + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/display.rb:33 + def wrap_layout(contents); end +end + +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/gems.rb:5 +class YARD::CLI::Gems < ::YARD::CLI::Command + # @return [Gems] a new instance of Gems + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:6 + def initialize; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:11 + def description; end + + # Runs the commandline utility, parsing arguments and generating + # YARD indexes for gems. + # + # @param args [Array<String>] the list of arguments + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:18 + def run(*args); end + + private + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:47 + def add_gems(gems); end + + # Builds .yardoc files for all non-existing gems + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:27 + def build_gems; end + + # Parses options + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/gems.rb:61 + def optparse(*args); end +end + +# A command-line utility to generate Graphviz graphs from +# a set of objects +# +# @see Graph#run +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/graph.rb:27 +class YARD::CLI::Graph < ::YARD::CLI::YardoptsCommand + # Creates a new instance of the command-line utility + # + # @return [Graph] a new instance of Graph + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:34 + def initialize; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:42 + def description; end + + # The set of objects to include in the graph. + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:31 + def objects; end + + # The options parsed out of the commandline. + # Default options are: + # :format => :dot + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:28 + def options; end + + # Runs the command-line utility. + # + # @example + # grapher = Graph.new + # grapher.run('--private') + # @param args [Array<String>] each tokenized argument + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:52 + def run(*args); end + + private + + # Parses commandline options. + # + # @param args [Array<String>] each tokenized argument + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:69 + def optparse(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:65 + def unrecognized_option(err); end +end + +# Options to pass to the {Graph} CLI. +# +# source://yard-0.9.28/lib/yard/cli/graph.rb:6 +class YARD::CLI::GraphOptions < ::YARD::Templates::TemplateOptions + # @return [String] any contents to pass to the digraph + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:16 + def contents; end + + # @return [String] any contents to pass to the digraph + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:16 + def contents=(_arg0); end + + # @return [Boolean] whether to show the object dependencies + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:13 + def dependencies; end + + # @return [Boolean] whether to show the object dependencies + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:13 + def dependencies=(_arg0); end + + # @return [:dot] the default output format + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def format; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def format=(_arg0); end + + # @return [Boolean] whether to list the full class diagram + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:10 + def full; end + + # @return [Boolean] whether to list the full class diagram + # + # source://yard-0.9.28/lib/yard/cli/graph.rb:10 + def full=(_arg0); end +end + +# Handles help for commands +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/help.rb:6 +class YARD::CLI::Help < ::YARD::CLI::Command + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/help.rb:7 + def description; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/help.rb:9 + def run(*args); end +end + +# CLI command to support internationalization (a.k.a. i18n). +# I18n feature is based on gettext technology. +# This command generates .pot file from docstring and extra +# documentation. +# +# @since 0.8.0 +# @todo Support msgminit and msgmerge features? +# +# source://yard-0.9.28/lib/yard/cli/i18n.rb:13 +class YARD::CLI::I18n < ::YARD::CLI::Yardoc + # @return [I18n] a new instance of I18n + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/cli/i18n.rb:14 + def initialize; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/cli/i18n.rb:19 + def description; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/cli/i18n.rb:23 + def run(*args); end + + private + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/cli/i18n.rb:44 + def general_options(opts); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/cli/i18n.rb:61 + def generate_pot(relative_base_path); end +end + +# Lists all constant and method names in the codebase. Uses {Yardoc} --list. +# +# source://yard-0.9.28/lib/yard/cli/list.rb:5 +class YARD::CLI::List < ::YARD::CLI::Command + # source://yard-0.9.28/lib/yard/cli/list.rb:6 + def description; end + + # Runs the commandline utility, parsing arguments and displaying a + # list of objects + # + # @param args [Array<String>] the list of arguments. + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/list.rb:13 + def run(*args); end +end + +# Lists all markup types +# +# @since 0.8.6 +# +# source://yard-0.9.28/lib/yard/cli/markup_types.rb:6 +class YARD::CLI::MarkupTypes < ::YARD::CLI::Command + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/markup_types.rb:7 + def description; end + + # Runs the commandline utility, parsing arguments and displaying a + # list of markup types + # + # @param args [Array<String>] the list of arguments. + # @return [void] + # @since 0.8.6 + # + # source://yard-0.9.28/lib/yard/cli/markup_types.rb:14 + def run(*args); end +end + +# A local documentation server +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/server.rb:8 +class YARD::CLI::Server < ::YARD::CLI::Command + # Creates a new instance of the Server command line utility + # + # @return [Server] a new instance of Server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:29 + def initialize; end + + # @return [YARD::Server::Adapter] the adapter to use for loading the web server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:18 + def adapter; end + + # @return [YARD::Server::Adapter] the adapter to use for loading the web server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:18 + def adapter=(_arg0); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:41 + def description; end + + # @return [Hash] a list of library names and yardoc files to serve + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:15 + def libraries; end + + # @return [Hash] a list of library names and yardoc files to serve + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:15 + def libraries=(_arg0); end + + # @return [Hash] a list of options to pass to the doc server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:9 + def options; end + + # @return [Hash] a list of options to pass to the doc server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:9 + def options=(_arg0); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:45 + def run(*args); end + + # @return [Array<String>] a list of scripts to load + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:22 + def scripts; end + + # @return [Array<String>] a list of scripts to load + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:22 + def scripts=(_arg0); end + + # @return [Hash] a list of options to pass to the web server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:12 + def server_options; end + + # @return [Hash] a list of options to pass to the web server + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:12 + def server_options=(_arg0); end + + # @return [Array<String>] a list of template paths to register + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:26 + def template_paths; end + + # @return [Array<String>] a list of template paths to register + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:26 + def template_paths=(_arg0); end + + private + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:131 + def add_gems; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:140 + def add_gems_from_gemfile(gemfile = T.unsafe(nil)); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:76 + def add_libraries(args); end + + # @param library [String] The library name. + # @param dir [String, nil] The argument provided on the CLI after the + # library name. Is supposed to point to either a project directory + # with a Yard options file, or a yardoc db. + # @return [LibraryVersion, nil] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:115 + def create_library_version_if_yardopts_exist(library, dir); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:249 + def extract_db_from_options_file(options_file); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:239 + def generate_doc_for_first_time(libver); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:56 + def load_scripts; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:60 + def load_template_paths; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:156 + def optparse(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/server.rb:66 + def select_adapter; end +end + +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/stats.rb:5 +class YARD::CLI::Stats < ::YARD::CLI::Yardoc + include ::YARD::Templates::Helpers::BaseHelper + + # @param parse [Boolean] whether to parse and load registry (see {#parse}) + # @return [Stats] a new instance of Stats + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:18 + def initialize(parse = T.unsafe(nil)); end + + # @return [Array<CodeObjects::Base>] all the parsed objects in the registry, + # removing any objects that are not visible (private, protected) depending + # on the arguments passed to the command. + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:108 + def all_objects; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:25 + def description; end + + # Prints a statistic to standard out. This method is optimized for + # getting Integer values, though it allows any data to be printed. + # + # @param name [String] the statistic name + # @param data [Integer, String] the numeric (or any) data representing + # the statistic. If +data+ is an Integer, it should represent the + # total objects of a type. + # @param undoc [Integer, nil] number of undocumented objects for the type + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:162 + def output(name, data, undoc = T.unsafe(nil)); end + + # @return [Boolean] whether to parse and load registry + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:15 + def parse; end + + # @return [Boolean] whether to parse and load registry + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:15 + def parse=(_arg0); end + + # Prints statistics for different object types + # + # To add statistics for a specific type, add a method +#stats_for_TYPE+ + # to this class that calls {#output}. + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:54 + def print_statistics; end + + # Prints list of undocumented objects + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:79 + def print_undocumented_objects; end + + # Runs the commandline utility, parsing arguments and generating + # output if set. + # + # @param args [Array<String>] the list of arguments + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:34 + def run(*args); end + + # Statistics for attributes + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:135 + def stats_for_attributes; end + + # Statistics for classes + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:125 + def stats_for_classes; end + + # Statistics for constants + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:130 + def stats_for_constants; end + + # Statistics for files + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:113 + def stats_for_files; end + + # Statistics for methods + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:144 + def stats_for_methods; end + + # Statistics for modules + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:120 + def stats_for_modules; end + + private + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:199 + def general_options(opts); end + + # Parses commandline options. + # + # @param args [Array<String>] each tokenized argument + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:185 + def optparse(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/stats.rb:176 + def type_statistics(type); end +end + +# Maintains the order in which +stats_for_+ statistics methods should be +# printed. +# +# @see #print_statistics +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/stats.rb:12 +YARD::CLI::Stats::STATS_ORDER = T.let(T.unsafe(nil), Array) + +# A tool to view documentation in the console like `ri` +# +# source://yard-0.9.28/lib/yard/cli/yri.rb:9 +class YARD::CLI::YRI < ::YARD::CLI::Command + # @return [YRI] a new instance of YRI + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:31 + def initialize; end + + # source://yard-0.9.28/lib/yard/cli/yri.rb:41 + def description; end + + # Runs the command-line utility. + # + # @example + # YRI.new.run('String#reverse') + # @param args [Array<String>] each tokenized argument + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:50 + def run(*args); end + + protected + + # Caches the .yardoc file where an object can be found in the {CACHE_FILE} + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:85 + def cache_object(name, path); end + + # Locates an object by name starting in the cached paths and then + # searching through any search paths. + # + # @param name [String] the full name of the object + # @return [CodeObjects::Base] an object if found + # @return [nil] if no object is found + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:113 + def find_object(name); end + + # @param object [CodeObjects::Base] the object to print. + # @return [String] the formatted output for an object. + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:98 + def print_object(object); end + + # Prints the command usage + # + # @return [void] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:78 + def print_usage; end + + private + + # Adds paths in {SEARCH_PATHS_FILE} + # + # @since 0.5.1 + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:181 + def add_default_paths; end + + # Adds all RubyGems yardoc files to search paths + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:161 + def add_gem_paths; end + + # Loads {CACHE_FILE} + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:151 + def load_cache; end + + # Parses commandline options. + # + # @param args [Array<String>] each tokenized argument + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:190 + def optparse(*args); end + + # Tries to load the object with name. If successful, caches the object + # with the cache_path + # + # @param name [String] the object path + # @param cache_path [String] the location of the yardoc + # db containing the object to cache for future lookups. + # No caching is done if this is nil. + # @return [void] + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:143 + def try_load_object(name, cache_path); end + + class << self + # Helper method to run the utility on an instance. + # + # @see #run + # + # source://yard-0.9.28/lib/yard/cli/yri.rb:29 + def run(*args); end + end +end + +# The location in {YARD::CONFIG_DIR} where the YRI cache file is loaded +# from. +# +# source://yard-0.9.28/lib/yard/cli/yri.rb:10 +YARD::CLI::YRI::CACHE_FILE = T.let(T.unsafe(nil), String) + +# Default search paths that should be loaded dynamically into YRI. These paths +# take precedence over all other paths ({SEARCH_PATHS_FILE} and RubyGems +# paths). To add a path, call: +# +# DEFAULT_SEARCH_PATHS.push("/path/to/.yardoc") +# +# @return [Array<String>] a list of extra search paths +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/cli/yri.rb:25 +YARD::CLI::YRI::DEFAULT_SEARCH_PATHS = T.let(T.unsafe(nil), Array) + +# A file containing all paths, delimited by newlines, to search for +# yardoc databases. +# +# @since 0.5.1 +# +# source://yard-0.9.28/lib/yard/cli/yri.rb:15 +YARD::CLI::YRI::SEARCH_PATHS_FILE = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/cli/yardoc.rb:147 +class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand + # Creates a new instance of the commandline utility + # + # @return [Yardoc] a new instance of Yardoc + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:207 + def initialize; end + + # The list of all objects to process. Override this method to change + # which objects YARD should generate documentation for. + # + # @deprecated To hide methods use the +@private+ tag instead. + # @return [Array<CodeObjects::Base>] a list of code objects to process + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:330 + def all_objects; end + + # Keep track of which APIs are to be shown + # + # @return [Array<String>] a list of APIs + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:180 + def apis; end + + # Keep track of which APIs are to be shown + # + # @return [Array<String>] a list of APIs + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:180 + def apis=(_arg0); end + + # @return [Array<String>] a list of assets to copy after generation + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:197 + def assets; end + + # @return [Array<String>] a list of assets to copy after generation + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:197 + def assets=(_arg0); end + + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:234 + def description; end + + # @return [Array<String>] list of excluded paths (regexp matches) + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:155 + def excluded; end + + # @return [Array<String>] list of excluded paths (regexp matches) + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:155 + def excluded=(_arg0); end + + # @return [Boolean] whether yard exits with error status code if a warning occurs + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:204 + def fail_on_warning; end + + # @return [Boolean] whether yard exits with error status code if a warning occurs + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:204 + def fail_on_warning=(_arg0); end + + # @return [Array<String>] list of Ruby source files to process + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:151 + def files; end + + # @return [Array<String>] list of Ruby source files to process + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:151 + def files=(_arg0); end + + # @return [Boolean] whether to generate output + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:166 + def generate; end + + # @return [Boolean] whether to generate output + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:166 + def generate=(_arg0); end + + # @return [Boolean] whether markup option was specified + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:201 + def has_markup; end + + # @return [Boolean] whether markup option was specified + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:201 + def has_markup=(_arg0); end + + # Keep track of which APIs are to be hidden + # + # @return [Array<String>] a list of APIs to be hidden + # @since 0.8.7 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:185 + def hidden_apis; end + + # Keep track of which APIs are to be hidden + # + # @return [Array<String>] a list of APIs to be hidden + # @since 0.8.7 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:185 + def hidden_apis=(_arg0); end + + # @return [Array<Symbol>] a list of tags to hide from templates + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:189 + def hidden_tags; end + + # @return [Array<Symbol>] a list of tags to hide from templates + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:189 + def hidden_tags=(_arg0); end + + # @return [Boolean] whether to print a list of objects + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:170 + def list; end + + # @return [Boolean] whether to print a list of objects + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:170 + def list=(_arg0); end + + # @return [Hash] the hash of options passed to the template. + # @see Templates::Engine#render + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:148 + def options; end + + # Parses commandline arguments + # + # @param args [Array<String>] the list of arguments + # @return [Boolean] whether or not arguments are valid + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:291 + def parse_arguments(*args); end + + # Runs the commandline utility, parsing arguments and generating + # output if set. + # + # @param args [Array<String>] the list of arguments. If the list only + # contains a single nil value, skip calling of {#parse_arguments} + # @return [void] + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:244 + def run(*args); end + + # @return [Boolean] whether objects should be serialized to .yardoc db + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:163 + def save_yardoc; end + + # @return [Boolean] whether objects should be serialized to .yardoc db + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:163 + def save_yardoc=(_arg0); end + + # @return [Boolean] whether to print statistics after parsing + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:193 + def statistics; end + + # @return [Boolean] whether to print statistics after parsing + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:193 + def statistics=(_arg0); end + + # @return [Boolean] whether to use the existing yardoc db if the + # .yardoc already exists. Also makes use of file checksums to + # parse only changed files. + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:160 + def use_cache; end + + # @return [Boolean] whether to use the existing yardoc db if the + # .yardoc already exists. Also makes use of file checksums to + # parse only changed files. + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:160 + def use_cache=(_arg0); end + + # Keep track of which visibilities are to be shown + # + # @return [Array<Symbol>] a list of visibilities + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:175 + def visibilities; end + + # Keep track of which visibilities are to be shown + # + # @return [Array<Symbol>] a list of visibilities + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:175 + def visibilities=(_arg0); end + + private + + # Adds verifier rule for APIs + # + # @return [void] + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:474 + def add_api_verifier; end + + # Adds a set of extra documentation files to be processed + # + # @param files [Array<String>] the set of documentation files + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:413 + def add_extra_files(*files); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:507 + def add_tag(tag_data, factory_method = T.unsafe(nil)); end + + # Adds verifier rule for visibilities + # + # @return [void] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:466 + def add_visibility_verifier; end + + # Applies the specified locale to collected objects + # + # @return [void] + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:494 + def apply_locale; end + + # Copies any assets to the output directory + # + # @return [void] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:389 + def copy_assets; end + + # @param file [String] the filename to validate + # @param check_exists [Boolean] whether the file should exist on disk + # @return [Boolean] whether the file is allowed to be used + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:425 + def extra_file_valid?(file, check_exists = T.unsafe(nil)); end + + # Adds general options + # + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:541 + def general_options(opts); end + + # Parses commandline options. + # + # @param args [Array<String>] each tokenized argument + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:516 + def optparse(*args); end + + # Adds output options + # + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:586 + def output_options(opts); end + + # Parses the file arguments into Ruby files and extra files, which are + # separated by a '-' element. + # + # @example Parses a set of Ruby source files + # parse_files %w(file1 file2 file3) + # @example Parses a set of Ruby files with a separator and extra files + # parse_files %w(file1 file2 - extrafile1 extrafile2) + # @param files [Array<String>] the list of files to parse + # @return [void] + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:446 + def parse_files(*files); end + + # Prints a list of all objects + # + # @return [void] + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:403 + def print_list; end + + # Generates output for objects + # + # @param checksums [Hash, nil] if supplied, a list of checkums for files. + # @return [void] + # @since 0.5.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:340 + def run_generate(checksums); end + + # Runs a list of objects against the {Verifier} object passed into the + # template and returns the subset of verified objects. + # + # @param list [Array<CodeObjects::Base>] a list of code objects + # @return [Array<CodeObjects::Base>] a list of code objects that match + # the verifier. If no verifier is supplied, all objects are returned. + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:502 + def run_verifier(list); end + + # Adds tag options + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:753 + def tag_options(opts); end + + # Verifies that the markup options are valid before parsing any code. + # Failing early is better than failing late. + # + # @return [Boolean] whether the markup provider was successfully loaded. + # @since 0.2.1 + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:364 + def verify_markup_options; end +end + +# Default options used in +yard doc+ command. +# +# source://yard-0.9.28/lib/yard/cli/yardoc.rb:10 +class YARD::CLI::YardocOptions < ::YARD::Templates::TemplateOptions + # @return [CodeObjects::ExtraFileObject] the file object being rendered. + # The +object+ key is not used so that a file may be rendered in the context + # of an object's namespace (for generating links). + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:48 + def file; end + + # @return [CodeObjects::ExtraFileObject] the file object being rendered. + # The +object+ key is not used so that a file may be rendered in the context + # of an object's namespace (for generating links). + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:48 + def file=(_arg0); end + + # @return [Array<CodeObjects::ExtraFileObject>] the list of extra files rendered along with objects + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def files; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def files=(_arg0); end + + # @return [Symbol] the default output format (:html). + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def format; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def format=(_arg0); end + + # @return [Numeric] An index value for rendering sequentially related templates + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:39 + def index; end + + # @return [Numeric] An index value for rendering sequentially related templates + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:39 + def index=(_arg0); end + + # @return [CodeObjects::Base] an extra item to send to a template that is not + # the main rendered object + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:43 + def item; end + + # @return [CodeObjects::Base] an extra item to send to a template that is not + # the main rendered object + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:43 + def item=(_arg0); end + + # @return [String] the current locale + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:51 + def locale; end + + # @return [String] the current locale + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:51 + def locale=(_arg0); end + + # @return [Array<CodeObjects::Base>] the list of code objects to render + # the templates with. + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:36 + def objects; end + + # @return [Array<CodeObjects::Base>] the list of code objects to render + # the templates with. + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:36 + def objects=(_arg0); end + + # @return [Boolean] whether the data should be rendered in a single page, + # if the template supports it. + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def onefile; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def onefile=(_arg0); end + + # @return [CodeObjects::ExtraFileObject] the README file object rendered + # along with objects + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:32 + def readme; end + + # @return [CodeObjects::ExtraFileObject] the README file object rendered + # along with objects + # + # source://yard-0.9.28/lib/yard/cli/yardoc.rb:32 + def readme=(_arg0); end + + # @return [Serializers::Base] the default serializer for generating output + # to disk. + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def serializer; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def serializer=(_arg0); end + + # @return [String] the default title appended to each generated page + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def title; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def title=(_arg0); end + + # @return [Verifier] the default verifier object to filter queries + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def verifier; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def verifier=(_arg0); end +end + +# Abstract base class for command that reads .yardopts file +# +# @abstract +# @since 0.8.3 +# +# source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:11 +class YARD::CLI::YardoptsCommand < ::YARD::CLI::Command + # Creates a new command that reads .yardopts + # + # @return [YardoptsCommand] a new instance of YardoptsCommand + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:25 + def initialize; end + + # The options file name (defaults to {DEFAULT_YARDOPTS_FILE}) + # + # @return [String] the filename to load extra options from + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:22 + def options_file; end + + # The options file name (defaults to {DEFAULT_YARDOPTS_FILE}) + # + # @return [String] the filename to load extra options from + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:22 + def options_file=(_arg0); end + + # Parses commandline arguments + # + # @param args [Array<String>] the list of arguments + # @return [Boolean] whether or not arguments are valid + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:36 + def parse_arguments(*args); end + + # @return [Boolean] whether to parse options from .document + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:18 + def use_document_file; end + + # @return [Boolean] whether to parse options from .document + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:18 + def use_document_file=(_arg0); end + + # @return [Boolean] whether to parse options from .yardopts + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:15 + def use_yardopts_file; end + + # @return [Boolean] whether to parse options from .yardopts + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:15 + def use_yardopts_file=(_arg0); end + + protected + + # Adds --[no-]yardopts / --[no-]document + # + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:48 + def yardopts_options(opts); end + + private + + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:92 + def parse_rdoc_document_file(file = T.unsafe(nil)); end + + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:96 + def parse_yardopts(file = T.unsafe(nil)); end + + # Parses out the yardopts/document options + # + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:78 + def parse_yardopts_options(*args); end + + # Reads a .document file in the directory to get source file globs + # + # @return [Array<String>] an array of files parsed from .document + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:102 + def support_rdoc_document_file!(file = T.unsafe(nil)); end + + # Parses the .yardopts file for default yard options + # + # @return [Array<String>] an array of options parsed from .yardopts + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:70 + def yardopts(file = T.unsafe(nil)); end +end + +# The configuration filename to load extra options from +# +# @since 0.8.3 +# +# source://yard-0.9.28/lib/yard/cli/yardopts_command.rb:12 +YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String) + +# @deprecated Use {Config::CONFIG_DIR} +# +# source://yard-0.9.28/lib/yard.rb:13 +YARD::CONFIG_DIR = T.let(T.unsafe(nil), String) + +# A "code object" is defined as any entity in the Ruby language. +# Classes, modules, methods, class variables and constants are the +# major objects, but DSL languages can create their own by inheriting +# from {CodeObjects::Base}. +# +# source://yard-0.9.28/lib/yard/autoload.rb:29 +module YARD::CodeObjects + extend ::YARD::CodeObjects::NamespaceMapper +end + +# All builtin Ruby classes and modules. +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:91 +YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array) + +# All builtin Ruby classes for inheritance tree. +# +# @note MatchingData is a 1.8.x legacy class +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:78 +YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array) + +# All builtin Ruby exception classes for inheritance tree. +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:67 +YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array) + +# Hash of {BUILTIN_EXCEPTIONS} as keys and true as value (for O(1) lookups) +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:94 +YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH = T.let(T.unsafe(nil), Hash) + +# All builtin Ruby modules for mixin handling. +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:87 +YARD::CodeObjects::BUILTIN_MODULES = T.let(T.unsafe(nil), Array) + +# +Base+ is the superclass of all code objects recognized by YARD. A code +# object is any entity in the Ruby language (class, method, module). A +# DSL might subclass +Base+ to create a new custom object representing +# a new entity type. +# +# == Registry Integration +# Any created object associated with a namespace is immediately registered +# with the registry. This allows the Registry to act as an identity map +# to ensure that no object is represented by more than one Ruby object +# in memory. A unique {#path} is essential for this identity map to work +# correctly. +# +# == Custom Attributes +# Code objects allow arbitrary custom attributes to be set using the +# {#[]=} assignment method. +# +# == Namespaces +# There is a special type of object called a "namespace". These are subclasses +# of the {NamespaceObject} and represent Ruby entities that can have +# objects defined within them. Classically these are modules and classes, +# though a DSL might create a custom {NamespaceObject} to describe a +# specific set of objects. +# +# == Separators +# Custom classes with different separator tokens should define their own +# separators using the {NamespaceMapper.register_separator} method. The +# standard Ruby separators have already been defined ('::', '#', '.', etc). +# +# @abstract This class should not be used directly. Instead, create a +# subclass that implements {#path}, {#sep} or {#type}. You might also +# need to register custom separators if {#sep} uses alternate separator +# tokens. +# @see Registry +# @see #path +# @see #[]= +# @see NamespaceObject +# @see NamespaceMapper.register_separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:133 +class YARD::CodeObjects::Base + # Creates a new code object + # + # @example Create a method in the root namespace + # CodeObjects::Base.new(:root, '#method') # => #<yardoc method #method> + # @example Create class Z inside namespace X::Y + # CodeObjects::Base.new(P("X::Y"), :Z) # or + # CodeObjects::Base.new(Registry.root, "X::Y") + # @param namespace [NamespaceObject] the namespace the object belongs in, + # {Registry.root} or :root should be provided if it is associated with + # the top level namespace. + # @param name [Symbol, String] the name (or complex path) of the object. + # @return [Base] the newly created object + # @yield [self] a block to perform any extra initialization on the object + # @yieldparam self [Base] the newly initialized code object + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:238 + def initialize(namespace, name, *_arg2); end + + # Tests if another object is equal to this, including a proxy + # + # @param other [Base, Proxy] if other is a {Proxy}, tests if + # the paths are equal + # @return [Boolean] whether or not the objects are considered the same + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:322 + def ==(other); end + + # Accesses a custom attribute on the object + # + # @param key [#to_s] the name of the custom attribute + # @return [Object, nil] the custom attribute or nil if not found. + # @see #[]= + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:342 + def [](key); end + + # Sets a custom attribute on the object + # + # @param key [#to_s] the name of the custom attribute + # @param value [Object] the value to associate + # @return [void] + # @see #[] + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:355 + def []=(key, value); end + + # Associates a file with a code object, optionally adding the line where it was defined. + # By convention, '<stdin>' should be used to associate code that comes form standard input. + # + # @param file [String] the filename ('<stdin>' for standard input) + # @param line [Fixnum, nil] the line number where the object lies in the file + # @param has_comments [Boolean] whether or not the definition has comments associated. This + # will allow {#file} to return the definition where the comments were made instead + # of any empty definitions that might have been parsed before (module namespaces for instance). + # @raise [ArgumentError] + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:290 + def add_file(file, line = T.unsafe(nil), has_comments = T.unsafe(nil)); end + + # Add tags to the {#docstring} + # + # @see Docstring#add_tag + # @since 0.8.4 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:557 + def add_tag(*tags); end + + # The non-localized documentation string associated with the object + # + # @return [Docstring] the documentation string + # @since 0.8.4 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:166 + def base_docstring; end + + # Copies all data in this object to another code object, except for + # uniquely identifying information (path, namespace, name, scope). + # + # @param other [Base] the object to copy data to + # @return [Base] the other object + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:263 + def copy_to(other); end + + # The documentation string associated with the object + # + # @param locale [String, I18n::Locale] (I18n::Locale.default) + # the locale of the documentation string. + # @return [Docstring] the documentation string + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:404 + def docstring(locale = T.unsafe(nil)); end + + # Attaches a docstring to a code object by parsing the comments attached to the statement + # and filling the {#tags} and {#docstring} methods with the parsed information. + # + # @param comments [String, Array<String>, Docstring] the comments attached to the code object to be parsed + # into a docstring and meta tags. + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:426 + def docstring=(comments); end + + # Marks whether or not the method is conditionally defined at runtime + # + # @return [Boolean] true if the method is conditionally defined at runtime + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:170 + def dynamic; end + + # Marks whether or not the method is conditionally defined at runtime + # + # @return [Boolean] true if the method is conditionally defined at runtime + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:170 + def dynamic=(_arg0); end + + # Is the object defined conditionally at runtime? + # + # @return [Boolean] + # @see #dynamic + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:178 + def dynamic?; end + + # Tests if another object is equal to this, including a proxy + # + # @param other [Base, Proxy] if other is a {Proxy}, tests if + # the paths are equal + # @return [Boolean] whether or not the objects are considered the same + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:322 + def eql?(other); end + + # Tests if another object is equal to this, including a proxy + # + # @param other [Base, Proxy] if other is a {Proxy}, tests if + # the paths are equal + # @return [Boolean] whether or not the objects are considered the same + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:322 + def equal?(other); end + + # Returns the filename the object was first parsed at, taking + # definitions with docstrings first. + # + # @return [String] a filename + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:306 + def file; end + + # The files the object was defined in. To add a file, use {#add_file}. + # + # @return [Array<Array(String, Integer)>] a list of files + # @see #add_file + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:137 + def files; end + + # Renders the object using the {Templates::Engine templating system}. + # + # @example Formats a class in plaintext + # puts P('MyClass').format + # @example Formats a method in html with rdoc markup + # puts P('MyClass#meth').format(:format => :html, :markup => :rdoc) + # @option options + # @option options + # @option options + # @option options + # @param options [Hash] a set of options to pass to the template + # @return [String] the rendered template + # @see Templates::Engine#render + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:501 + def format(options = T.unsafe(nil)); end + + # @return [String] the group this object is associated with + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:174 + def group; end + + # @return [String] the group this object is associated with + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:174 + def group=(_arg0); end + + # Tests if the {#docstring} has a tag + # + # @return [Boolean] + # @see Docstring#has_tag? + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:552 + def has_tag?(name); end + + # @return [Integer] the object's hash value (for equality checking) + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:333 + def hash; end + + # Inspects the object, returning the type and path + # + # @return [String] a string describing the object + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:509 + def inspect; end + + # Returns the line the object was first parsed at (or nil) + # + # @return [Fixnum] the line where the object was first defined. + # @return [nil] if there is no line associated with the object + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:314 + def line; end + + # @overload dynamic_attr_name + # @overload dynamic_attr_name= + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:372 + def method_missing(meth, *args, &block); end + + # The name of the object + # + # @param prefix [Boolean] whether to show a prefix. Implement + # this in a subclass to define how the prefix is showed. + # @return [Symbol] if prefix is false, the symbolized name + # @return [String] if prefix is true, prefix + the name as a String. + # This must be implemented by the subclass. + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:278 + def name(prefix = T.unsafe(nil)); end + + # The namespace the object is defined in. If the object is in the + # top level namespace, this is {Registry.root} + # + # @return [NamespaceObject] the namespace object + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:142 + def namespace; end + + # Sets the namespace the object is defined in. + # + # @param obj [NamespaceObject, :root, nil] the new namespace (:root + # for {Registry.root}). If obj is nil, the object is unregistered + # from the Registry. + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:518 + def namespace=(obj); end + + # The namespace the object is defined in. If the object is in the + # top level namespace, this is {Registry.root} + # + # @return [NamespaceObject] the namespace object + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:142 + def parent; end + + # Sets the namespace the object is defined in. + # + # @param obj [NamespaceObject, :root, nil] the new namespace (:root + # for {Registry.root}). If obj is nil, the object is unregistered + # from the Registry. + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:518 + def parent=(obj); end + + # Represents the unique path of the object. The default implementation + # joins the path of {#namespace} with {#name} via the value of {#sep}. + # Custom code objects should ensure that the path is unique to the code + # object by either overriding {#sep} or this method. + # + # @example The path of an instance method + # MethodObject.new(P("A::B"), :c).path # => "A::B#c" + # @return [String] the unique path of the object + # @see #sep + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:449 + def path; end + + # @param other [Base, String] another code object (or object path) + # @return [String] the shortest relative path from this object to +other+ + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:471 + def relative_path(other); end + + # @return [Boolean] whether or not this object is a RootObject + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:563 + def root?; end + + # Override this method with a custom component separator. For instance, + # {MethodObject} implements sep as '#' or '.' (depending on if the + # method is instance or class respectively). {#path} depends on this + # value to generate the full path in the form: namespace.path + sep + name + # + # @return [String] the component that separates the namespace path + # and the name (default is {NSEP}) + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:572 + def sep; end + + # The one line signature representing an object. For a method, this will + # be of the form "def meth(arguments...)". This is usually the first + # source line. + # + # @return [String] a line of source + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:159 + def signature; end + + # The one line signature representing an object. For a method, this will + # be of the form "def meth(arguments...)". This is usually the first + # source line. + # + # @return [String] a line of source + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:159 + def signature=(_arg0); end + + # The source code associated with the object + # + # @return [String, nil] source, if present, or nil + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:146 + def source; end + + # Attaches source code to a code object with an optional file location + # + # @param statement [#source, String] the +Parser::Statement+ holding the source code or the raw source + # as a +String+ for the definition of the code object only (not the block) + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:387 + def source=(statement); end + + # Language of the source code associated with the object. Defaults to + # +:ruby+. + # + # @return [Symbol] the language type + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:152 + def source_type; end + + # Language of the source code associated with the object. Defaults to + # +:ruby+. + # + # @return [Symbol] the language type + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:152 + def source_type=(_arg0); end + + # Gets a tag from the {#docstring} + # + # @see Docstring#tag + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:544 + def tag(name); end + + # Gets a list of tags from the {#docstring} + # + # @see Docstring#tags + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:548 + def tags(name = T.unsafe(nil)); end + + # @note Override this method if your object has a special title that does + # not match the {#path} attribute value. This title will be used + # when linking or displaying the object. + # @return [String] the display title for an object + # @see 0.8.4 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:464 + def title; end + + # @return [nil] this object does not turn into an array + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:336 + def to_ary; end + + # Represents the unique path of the object. The default implementation + # joins the path of {#namespace} with {#name} via the value of {#sep}. + # Custom code objects should ensure that the path is unique to the code + # object by either overriding {#sep} or this method. + # + # @example The path of an instance method + # MethodObject.new(P("A::B"), :c).path # => "A::B#c" + # @return [String] the unique path of the object + # @see #sep + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:449 + def to_s; end + + # Default type is the lowercase class name without the "Object" suffix. + # Override this method to provide a custom object type + # + # @return [Symbol] the type of code object this represents + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:436 + def type; end + + # @return [Symbol] the visibility of an object (:public, :private, :protected) + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:181 + def visibility; end + + # @return [Symbol] the visibility of an object (:public, :private, :protected) + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:183 + def visibility=(v); end + + protected + + # Override this method if your code object subclass does not allow + # copying of certain attributes. + # + # @return [Array<String>] the list of instance variable names (without + # "@" prefix) that should be copied when {#copy_to} is called + # @see #copy_to + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:583 + def copyable_attributes; end + + private + + # Formats source code by removing leading indentation + # + # @param source [String] the source code to format + # @return [String] formatted source + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:595 + def format_source(source); end + + # source://yard-0.9.28/lib/yard/code_objects/base.rb:602 + def translate_docstring(locale); end + + class << self + # Compares the class with subclasses + # + # @param other [Object] the other object to compare classes with + # @return [Boolean] true if other is a subclass of self + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:219 + def ===(other); end + + # Allocates a new code object + # + # @raise [ArgumentError] + # @return [Base] + # @see #initialize + # @yield [obj] + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:189 + def new(namespace, name, *args, &block); end + end +end + +# Regular expression to match constant name +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:52 +YARD::CodeObjects::CONSTANTMATCH = T.let(T.unsafe(nil), Regexp) + +# Regular expression to match the beginning of a constant +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:55 +YARD::CodeObjects::CONSTANTSTART = T.let(T.unsafe(nil), Regexp) + +# Class method separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:46 +YARD::CodeObjects::CSEP = T.let(T.unsafe(nil), String) + +# Regex-quoted class method separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:49 +YARD::CodeObjects::CSEPQ = T.let(T.unsafe(nil), String) + +# A ClassObject represents a Ruby class in source code. It is a {ModuleObject} +# with extra inheritance semantics through the superclass. +# +# source://yard-0.9.28/lib/yard/code_objects/class_object.rb:9 +class YARD::CodeObjects::ClassObject < ::YARD::CodeObjects::NamespaceObject + # Creates a new class object in +namespace+ with +name+ + # + # @return [ClassObject] a new instance of ClassObject + # @see Base.new + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:15 + def initialize(namespace, name, *args, &block); end + + # Returns the list of constants matching the options hash. + # + # @option opts + # @option opts + # @param opts [Hash] the options hash to match + # @return [Array<ConstantObject>] the list of constant that matched + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:101 + def constants(opts = T.unsafe(nil)); end + + # Returns the inheritance tree of the object including self. + # + # @param include_mods [Boolean] whether or not to include mixins in the + # inheritance tree. + # @return [Array<NamespaceObject>] the list of code objects that make up + # the inheritance tree. + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:45 + def inheritance_tree(include_mods = T.unsafe(nil)); end + + # Returns only the constants that were inherited. + # + # @return [Array<ConstantObject>] the list of inherited constant objects + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:109 + def inherited_constants; end + + # Returns only the methods that were inherited. + # + # @return [Array<MethodObject>] the list of inherited method objects + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:79 + def inherited_meths(opts = T.unsafe(nil)); end + + # Whether or not the class is a Ruby Exception + # + # @return [Boolean] whether the object represents a Ruby exception + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:35 + def is_exception?; end + + # Returns the list of methods matching the options hash. Returns + # all methods if hash is empty. + # + # @option opts + # @option opts + # @param opts [Hash] the options hash to match + # @return [Array<MethodObject>] the list of methods that matched + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:66 + def meths(opts = T.unsafe(nil)); end + + # The {ClassObject} that this class object inherits from in Ruby source. + # + # @return [ClassObject] a class object that is the superclass of this one + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:10 + def superclass; end + + # Sets the superclass of the object + # + # @param object [Base, Proxy, String, Symbol, nil] the superclass value + # @return [void] + # + # source://yard-0.9.28/lib/yard/code_objects/class_object.rb:125 + def superclass=(object); end +end + +# Represents a class variable inside a namespace. The path is expressed +# in the form "A::B::@@classvariable" +# +# source://yard-0.9.28/lib/yard/code_objects/class_variable_object.rb:8 +class YARD::CodeObjects::ClassVariableObject < ::YARD::CodeObjects::Base + # @return [String] the class variable's value + # + # source://yard-0.9.28/lib/yard/code_objects/class_variable_object.rb:9 + def value; end + + # @return [String] the class variable's value + # + # source://yard-0.9.28/lib/yard/code_objects/class_variable_object.rb:9 + def value=(_arg0); end +end + +# A list of code objects. This array acts like a set (no unique items) +# but also disallows any {Proxy} objects from being added. +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:10 +class YARD::CodeObjects::CodeObjectList < ::Array + # Creates a new object list associated with a namespace + # + # @param owner [NamespaceObject] the namespace the list should be associated with + # @return [CodeObjectList] + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:11 + def initialize(owner = T.unsafe(nil)); end + + # Adds a new value to the list + # + # @param value [Base] a code object to add + # @return [CodeObjectList] self + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:19 + def <<(value); end + + # Adds a new value to the list + # + # @param value [Base] a code object to add + # @return [CodeObjectList] self + # + # source://yard-0.9.28/lib/yard/code_objects/base.rb:19 + def push(value); end +end + +# A +ConstantObject+ represents a Ruby constant (not a module or class). +# To access the constant's (source code) value, use {#value}. +# +# source://yard-0.9.28/lib/yard/code_objects/constant_object.rb:9 +class YARD::CodeObjects::ConstantObject < ::YARD::CodeObjects::Base + # The source code representing the constant's value + # + # @return [String] the value the constant is set to + # + # source://yard-0.9.28/lib/yard/code_objects/constant_object.rb:10 + def value; end + + # source://yard-0.9.28/lib/yard/code_objects/constant_object.rb:12 + def value=(value); end +end + +# Represents an instance method of a module that was mixed into the class +# scope of another namespace. +# +# @see MethodObject +# +# source://yard-0.9.28/lib/yard/code_objects/extended_method_object.rb:7 +class YARD::CodeObjects::ExtendedMethodObject + # Sets up a delegate for {MethodObject} obj. + # + # @param obj [MethodObject] the instance method to treat as a mixed in + # class method on another namespace. + # @return [ExtendedMethodObject] a new instance of ExtendedMethodObject + # + # source://yard-0.9.28/lib/yard/code_objects/extended_method_object.rb:17 + def initialize(obj); end + + # Sends all methods to the {MethodObject} assigned in {#initialize} + # + # @see #initialize + # @see MethodObject + # + # source://yard-0.9.28/lib/yard/code_objects/extended_method_object.rb:22 + def method_missing(sym, *args, &block); end + + # @return [Symbol] always +:class+ + # + # source://yard-0.9.28/lib/yard/code_objects/extended_method_object.rb:11 + def scope; end +end + +# An ExtraFileObject represents an extra documentation file (README or other +# file). It is not strictly a CodeObject (does not inherit from `Base`) although +# it implements `path`, `name` and `type`, and therefore should be structurally +# compatible with most CodeObject interfaces. +# +# source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:7 +class YARD::CodeObjects::ExtraFileObject + # Creates a new extra file object. + # + # @param filename [String] the location on disk of the file + # @param contents [String] the file contents. If not set, the contents + # will be read from disk using the +filename+. + # @return [ExtraFileObject] a new instance of ExtraFileObject + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:18 + def initialize(filename, contents = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:64 + def ==(other); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:30 + def attributes; end + + # Sets the attribute attributes + # + # @param value the value to set the attribute attributes to. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:9 + def attributes=(_arg0); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:39 + def contents; end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:44 + def contents=(contents); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:64 + def eql?(other); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:64 + def equal?(other); end + + # Returns the value of attribute filename. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:8 + def filename; end + + # Sets the attribute filename + # + # @param value the value to set the attribute filename to. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:8 + def filename=(_arg0); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:70 + def hash; end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:57 + def inspect; end + + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:12 + def locale; end + + # @param locale [String] the locale name to be translated. + # @return [void] + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:52 + def locale=(locale); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:10 + def name; end + + # Sets the attribute name + # + # @param value the value to set the attribute name to. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:10 + def name=(_arg0); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:10 + def path; end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:35 + def title; end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:57 + def to_s; end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:62 + def type; end + + private + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:74 + def ensure_parsed; end + + # @param data [String] the file contents + # + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:81 + def parse_contents(data); end + + # source://yard-0.9.28/lib/yard/code_objects/extra_file_object.rb:129 + def translate(data); end +end + +# Instance method separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:40 +YARD::CodeObjects::ISEP = T.let(T.unsafe(nil), String) + +# Regex-quoted instance method separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:43 +YARD::CodeObjects::ISEPQ = T.let(T.unsafe(nil), String) + +# Regular expression to match a fully qualified method def (self.foo, Class.foo). +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:64 +YARD::CodeObjects::METHODMATCH = T.let(T.unsafe(nil), Regexp) + +# Regular expression to match a method name +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:61 +YARD::CodeObjects::METHODNAMEMATCH = T.let(T.unsafe(nil), Regexp) + +# A MacroObject represents a docstring defined through +@!macro NAME+ and can be +# reused by specifying the tag +@!macro NAME+. You can also provide the +# +attached+ type flag to the macro definition to have it attached to the +# specific DSL method so it will be implicitly reused. +# +# Macros are fully described in the {file:docs/Tags.md#macro Tags Overview} +# document. +# +# @example Creating a basic named macro +# # @!macro prop +# # @!method $1(${3-}) +# # @return [$2] the value of the $0 +# property :foo, String, :a, :b +# +# # @!macro prop +# property :bar, Numeric, :value +# @example Creating a macro that is attached to the method call +# # @!macro [attach] prop2 +# # @!method $1(value) +# property :foo +# +# # Extra data added to docstring +# property :bar +# +# source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:30 +class YARD::CodeObjects::MacroObject < ::YARD::CodeObjects::Base + # @return [Boolean] whether this macro is attached to a method + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:149 + def attached?; end + + # Expands the macro using + # + # @example Expanding a Macro + # macro.expand(%w(property foo bar), 'property :foo, :bar', '') #=> + # "...macro data interpolating this line of code..." + # @param call_params [Array<String>] a list of tokens that are passed + # to the method call + # @param full_source [String] the full method call (not including the block) + # @param block_source [String] the source passed in the block of the method + # call, if there is a block. + # @see expand + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:167 + def expand(call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end + + # @return [String] the macro data stored on the object + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:142 + def macro_data; end + + # @return [String] the macro data stored on the object + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:142 + def macro_data=(_arg0); end + + # @return [CodeObjects::Base] the method object that this macro is + # attached to. + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:146 + def method_object; end + + # @return [CodeObjects::Base] the method object that this macro is + # attached to. + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:146 + def method_object=(_arg0); end + + # Overrides {Base#path} so the macro path is ".macro.MACRONAME" + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:152 + def path; end + + # Overrides the separator to be '.' + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:155 + def sep; end + + class << self + # Applies a macro on a docstring by creating any macro data inside of + # the docstring first. Equivalent to calling {find_or_create} and {apply_macro} + # on the new macro object. + # + # @param docstring [Docstring] the docstring to create a macro out of + # @param call_params [Array<String>] the method name and parameters + # to the method call. These arguments will fill $0-N + # @param full_source [String] the full source line (excluding block) + # interpolated as $* + # @param block_source [String] Currently unused. Will support + # interpolating the block data as a variable. + # @return [String] the expanded macro data + # @see find_or_create + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:120 + def apply(docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil), _method_object = T.unsafe(nil)); end + + # Applies a macro to a docstring, interpolating the macro's data on the + # docstring and appending any extra local docstring data that was in + # the original +docstring+ object. + # + # @param macro [MacroObject] the macro object + # @param call_params [Array<String>] the method name and parameters + # to the method call. These arguments will fill $0-N + # @param full_source [String] the full source line (excluding block) + # interpolated as $* + # @param block_source [String] Currently unused. Will support + # interpolating the block data as a variable. + # @return [String] the expanded macro data + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:136 + def apply_macro(macro, docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end + + # Creates a new macro and fills in the relevant properties. + # + # @param macro_name [String] the name of the macro, must be unique. + # @param data [String] the data the macro should expand when re-used + # @param method_object [CodeObjects::Base] an object to attach this + # macro to. If supplied, {#attached?} will be true + # @return [MacroObject] the newly created object + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:40 + def create(macro_name, data, method_object = T.unsafe(nil)); end + + # Parses a given docstring and determines if the macro is "new" or + # not. If the macro has $variable names or if it has a @!macro tag + # with the [new] or [attached] flag, it is considered new. + # + # If a new macro is found, the macro is created and registered. Otherwise + # the macro name is searched and returned. If a macro is not found, + # nil is returned. + # + # @param macro_name [#to_s] the name of the macro + # @param method_object [CodeObjects::Base] an optional method to attach + # the macro to. Only used if the macro is being created, otherwise + # this argument is ignored. + # @return [MacroObject] the newly created or existing macro, depending + # on whether the @!macro tag was a new tag or not. + # @return [nil] if the +data+ has no macro tag or if the macro is + # not new and no macro by the macro name is found. + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:71 + def create_docstring(macro_name, data, method_object = T.unsafe(nil)); end + + # Expands +macro_data+ using the interpolation parameters. + # + # Interpolation rules: + # * $0, $1, $2, ... = the Nth parameter in +call_params+ + # * $* = the full statement source (excluding block) + # * Also supports $!{N-M} ranges, as well as negative indexes on N or M + # * Use \$ to escape the variable name in a macro. + # + # @param macro_data [String] the macro data to expand (taken from {#macro_data}) + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:93 + def expand(macro_data, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end + + # Finds a macro using +macro_name+ + # + # @param macro_name [#to_s] the name of the macro + # @return [MacroObject] if a macro is found + # @return [nil] if there is no registered macro by that name + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:51 + def find(macro_name); end + + # Parses a given docstring and determines if the macro is "new" or + # not. If the macro has $variable names or if it has a @!macro tag + # with the [new] or [attached] flag, it is considered new. + # + # If a new macro is found, the macro is created and registered. Otherwise + # the macro name is searched and returned. If a macro is not found, + # nil is returned. + # + # @param macro_name [#to_s] the name of the macro + # @param method_object [CodeObjects::Base] an optional method to attach + # the macro to. Only used if the macro is being created, otherwise + # this argument is ignored. + # @return [MacroObject] the newly created or existing macro, depending + # on whether the @!macro tag was a new tag or not. + # @return [nil] if the +data+ has no macro tag or if the macro is + # not new and no macro by the macro name is found. + # + # source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:71 + def find_or_create(macro_name, data, method_object = T.unsafe(nil)); end + end +end + +# source://yard-0.9.28/lib/yard/code_objects/macro_object.rb:31 +YARD::CodeObjects::MacroObject::MACRO_MATCH = T.let(T.unsafe(nil), Regexp) + +# Represents a Ruby method in source +# +# source://yard-0.9.28/lib/yard/code_objects/method_object.rb:10 +class YARD::CodeObjects::MethodObject < ::YARD::CodeObjects::Base + # Creates a new method object in +namespace+ with +name+ and an instance + # or class +scope+ + # + # If scope is +:module+, this object is instantiated as a public + # method in +:class+ scope, but also creates a new (empty) method + # as a private +:instance+ method on the same class or module. + # + # @param namespace [NamespaceObject] the namespace + # @param name [String, Symbol] the method name + # @param scope [Symbol] +:instance+, +:class+, or +:module+ + # @return [MethodObject] a new instance of MethodObject + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:37 + def initialize(namespace, name, scope = T.unsafe(nil), &block); end + + # Returns all alias names of the object + # + # @return [Array<MethodObject>] the alias names + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:149 + def aliases; end + + # Returns the read/writer info for the attribute if it is one + # + # @return [SymbolHash] if there is information about the attribute + # @return [nil] if the method is not an attribute + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:93 + def attr_info; end + + # @return [Boolean] whether or not the method is the #initialize constructor method + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:78 + def constructor?; end + + # Whether the object is explicitly defined in source or whether it was + # inferred by a handler. For instance, attribute methods are generally + # inferred and therefore not explicitly defined in source. + # + # @return [Boolean] whether the object is explicitly defined in source. + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:18 + def explicit; end + + # Whether the object is explicitly defined in source or whether it was + # inferred by a handler. For instance, attribute methods are generally + # inferred and therefore not explicitly defined in source. + # + # @return [Boolean] whether the object is explicitly defined in source. + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:18 + def explicit=(_arg0); end + + # Tests if the object is defined as an alias of another method + # + # @return [Boolean] whether the object is an alias + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:126 + def is_alias?; end + + # Tests if the object is defined as an attribute in the namespace + # + # @return [Boolean] whether the object is an attribute + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:114 + def is_attribute?; end + + # Tests boolean {#explicit} value. + # + # @return [Boolean] whether the method is explicitly defined in source + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:134 + def is_explicit?; end + + # @return [Boolean] whether or not this method was created as a module + # function + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:85 + def module_function?; end + + # Returns the name of the object. + # + # @example The name of an instance method (with prefix) + # an_instance_method.name(true) # => "#mymethod" + # @example The name of a class method (with prefix) + # a_class_method.name(true) # => "mymethod" + # @param prefix [Boolean] whether or not to show the prefix + # @return [String] returns {#sep} + +name+ for an instance method if + # prefix is true + # @return [Symbol] the name without {#sep} if prefix is set to false + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:175 + def name(prefix = T.unsafe(nil)); end + + # @return [MethodObject] the object that this method overrides + # @return [nil] if it does not override a method + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:141 + def overridden_method; end + + # Returns the list of parameters parsed out of the method signature + # with their default values. + # + # @return [Array<Array(String, String)>] a list of parameter names followed + # by their default values (or nil) + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:25 + def parameters; end + + # Returns the list of parameters parsed out of the method signature + # with their default values. + # + # @return [Array<Array(String, String)>] a list of parameter names followed + # by their default values (or nil) + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:25 + def parameters=(_arg0); end + + # Override path handling for instance methods in the root namespace + # (they should still have a separator as a prefix). + # + # @return [String] the path of a method + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:161 + def path; end + + # @return [Boolean] whether the method is a reader attribute + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:107 + def reader?; end + + # The scope of the method (+:class+ or +:instance+) + # + # @return [Symbol] the scope + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:11 + def scope; end + + # Changes the scope of an object from :instance or :class + # + # @param v [Symbol] the new scope + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:58 + def scope=(v); end + + # Override separator to differentiate between class and instance + # methods. + # + # @return [String] "#" for an instance method, "." for class + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:182 + def sep; end + + # @return [Boolean] whether the method is a writer attribute + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:100 + def writer?; end + + protected + + # source://yard-0.9.28/lib/yard/code_objects/method_object.rb:192 + def copyable_attributes; end +end + +# Represents a Ruby module. +# +# source://yard-0.9.28/lib/yard/code_objects/module_object.rb:11 +class YARD::CodeObjects::ModuleObject < ::YARD::CodeObjects::NamespaceObject + # Returns the inheritance tree of mixins. + # + # @param include_mods [Boolean] if true, will include mixed in + # modules (which is likely what is wanted). + # @return [Array<NamespaceObject>] a list of namespace objects + # + # source://yard-0.9.28/lib/yard/code_objects/module_object.rb:12 + def inheritance_tree(include_mods = T.unsafe(nil)); end +end + +# Regular expression to match namespaces (const A or complex path A::B) +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:58 +YARD::CodeObjects::NAMESPACEMATCH = T.let(T.unsafe(nil), Regexp) + +# Namespace separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:34 +YARD::CodeObjects::NSEP = T.let(T.unsafe(nil), String) + +# Regex-quoted namespace separator +# +# source://yard-0.9.28/lib/yard/code_objects/base.rb:37 +YARD::CodeObjects::NSEPQ = T.let(T.unsafe(nil), String) + +# This module controls registration and accessing of namespace separators +# for {Registry} lookup. +# +# @since 0.9.1 +# +# source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:8 +module YARD::CodeObjects::NamespaceMapper + # Clears the map of separators. + # + # @return [void] + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:55 + def clear_separators; end + + # Gets or sets the default separator value to use when no + # separator for the namespace can be determined. + # + # @example + # default_separator "::" + # @param value [String, nil] the default separator, or nil to return the + # value + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:68 + def default_separator(value = T.unsafe(nil)); end + + # Registers a separator with an optional set of valid types that + # must follow the separator lexically. + # + # Calls all callbacks defined by {NamespaceMapper.on_invalidate} after + # the separator is registered. + # + # @example Registering separators for a method object + # # Anything after a "#" denotes a method object + # register_separator "#", :method + # # Anything after a "." denotes a method object + # register_separator ".", :method + # @param sep [String] the separator string for the namespace + # @param valid_types [Array<Symbol>] a list of object types that + # must follow the separator. If the list is empty, any type can + # follow the separator. + # @see .on_invalidate + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:27 + def register_separator(sep, *valid_types); end + + # @return [Array<String>] all of the registered separators + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:80 + def separators; end + + # @param type [String] the type to return separators for + # @return [Array<Symbol>] a list of separators registered to a type + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:97 + def separators_for_type(type); end + + # @return [Regexp] the regexp match of all separators + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:85 + def separators_match; end + + # @param sep [String] the separator to return types for + # @return [Array<Symbol>] a list of types registered to a separator + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:91 + def types_for_separator(sep); end + + # Unregisters a separator by a type. + # + # @param type [Symbol] the type to unregister + # @see #register_separator + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:43 + def unregister_separator_by_type(type); end + + class << self + # @return [String] the default separator when no separator can begin + # determined. + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:137 + def default_separator; end + + # @return [String] the default separator when no separator can begin + # determined. + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:137 + def default_separator=(_arg0); end + + # Invalidates all separators + # + # @return [void] + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:125 + def invalidate; end + + # @return [Hash] a mapping of types to separators + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:114 + def map; end + + # @return [Regexp] the full list of separators as a regexp match + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:131 + def map_match; end + + # Adds a callback that triggers when a new separator is registered or + # the cache is cleared by invalidation. + # + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:107 + def on_invalidate(&block); end + + # @return [Hash] a reverse mapping of separators to types + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_mapper.rb:119 + def rev_map; end + end +end + +# A "namespace" is any object that can store other objects within itself. +# The two main Ruby objects that can act as namespaces are modules +# ({ModuleObject}) and classes ({ClassObject}). +# +# source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:11 +class YARD::CodeObjects::NamespaceObject < ::YARD::CodeObjects::Base + # Creates a new namespace object inside +namespace+ with +name+. + # + # @return [NamespaceObject] a new instance of NamespaceObject + # @see Base#initialize + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:56 + def initialize(namespace, name, *args, &block); end + + # A hash containing two keys, :class and :instance, each containing + # a hash of objects and their alias names. + # + # @return [Hash] a list of methods + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:44 + def aliases; end + + # A hash containing two keys, class and instance, each containing + # the attribute name with a { :read, :write } hash for the read and + # write objects respectively. + # + # @example The attributes of an object + # >> Registry.at('YARD::Docstring').attributes + # => { + # :class => { }, + # :instance => { + # :ref_tags => { + # :read => #<yardoc method YARD::Docstring#ref_tags>, + # :write => nil + # }, + # :object => { + # :read => #<yardoc method YARD::Docstring#object>, + # :write => #<yardoc method YARD::Docstring#object=> + # }, + # ... + # } + # } + # @return [Hash] a list of methods + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:39 + def attributes; end + + # Looks for a child that matches the attributes specified by +opts+. + # + # @example Finds a child by name and scope + # namespace.child(:name => :to_s, :scope => :instance) + # # => #<yardoc method MyClass#to_s> + # @return [Base, nil] the first matched child object, or nil + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:86 + def child(opts = T.unsafe(nil)); end + + # The list of objects defined in this namespace + # + # @return [Array<Base>] a list of objects + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:16 + def children; end + + # Only the class attributes + # + # @return [Hash] a list of method names and their read/write objects + # @see #attributes + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:69 + def class_attributes; end + + # Class mixins + # + # @return [Array<ModuleObject>] a list of mixins + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:48 + def class_mixins; end + + # Returns all constants in the namespace + # + # @option opts + # @param opts [Hash] a customizable set of options + # @return [Array<ConstantObject>] a list of constant objects + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:164 + def constants(opts = T.unsafe(nil)); end + + # Returns class variables defined in this namespace. + # + # @return [Array<ClassVariableObject>] a list of class variable objects + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:186 + def cvars; end + + # @return [Array<String>] a list of ordered group names inside the namespace + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:12 + def groups; end + + # @return [Array<String>] a list of ordered group names inside the namespace + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:12 + def groups=(_arg0); end + + # Returns constants included from any mixins + # + # @return [Array<ConstantObject>] a list of constant objects + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:172 + def included_constants; end + + # Returns methods included from any mixins that match the attributes + # specified by +opts+. If no options are specified, returns all included + # methods. + # + # @option opts + # @option opts + # @option opts + # @param opts [Hash] a customizable set of options + # @see #meths + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:144 + def included_meths(opts = T.unsafe(nil)); end + + # Only the instance attributes + # + # @return [Hash] a list of method names and their read/write objects + # @see #attributes + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:76 + def instance_attributes; end + + # Instance mixins + # + # @return [Array<ModuleObject>] a list of mixins + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:52 + def instance_mixins; end + + # Returns all methods that match the attributes specified by +opts+. If + # no options are provided, returns all methods. + # + # @example Finds all private and protected class methods + # namespace.meths(:visibility => [:private, :protected], :scope => :class) + # # => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>] + # @option opts + # @option opts + # @option opts + # @param opts [Hash] a customizable set of options + # @return [Array<MethodObject>] a list of method objects + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:113 + def meths(opts = T.unsafe(nil)); end + + # Returns for specific scopes. If no scopes are provided, returns all mixins. + # + # @param scopes [Array<Symbol>] a list of scopes (:class, :instance) to + # return mixins for. If this is empty, all scopes will be returned. + # @return [Array<ModuleObject>] a list of mixins + # + # source://yard-0.9.28/lib/yard/code_objects/namespace_object.rb:194 + def mixins(*scopes); end +end + +# @private +# +# source://yard-0.9.28/lib/yard/code_objects/proxy.rb:8 +YARD::CodeObjects::PROXY_MATCH = T.let(T.unsafe(nil), Regexp) + +# The Proxy class is a way to lazily resolve code objects in +# cases where the object may not yet exist. A proxy simply stores +# an unresolved path until a method is called on the object, at which +# point it does a lookup using {Registry.resolve}. If the object is +# not found, a warning is raised and {ProxyMethodError} might be raised. +# +# @example Creates a Proxy to the String class from a module +# # When the String class is parsed this method will +# # begin to act like the String ClassObject. +# Proxy.new(mymoduleobj, "String") +# @see Registry.resolve +# @see ProxyMethodError +# +# source://yard-0.9.28/lib/yard/code_objects/proxy.rb:24 +class YARD::CodeObjects::Proxy + # Creates a new Proxy + # + # @raise [ArgumentError] if namespace is not a NamespaceObject + # @return [Proxy] self + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:34 + def initialize(namespace, name, type = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:118 + def <=>(other); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:127 + def ==(other); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:113 + def ===(other); end + + # Returns the class name of the object the proxy is mimicking, if + # resolved. Otherwise returns +Proxy+. + # + # @return [Class] the resolved object's class or +Proxy+ + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:142 + def class; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:127 + def equal?(other); end + + # @return [Integer] the object's hash value (for equality checking) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:137 + def hash; end + + # Returns a text representation of the Proxy + # + # @return [String] the object's #inspect method or P(OBJECTPATH) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:91 + def inspect; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:161 + def instance_of?(klass); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:108 + def is_a?(klass); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:166 + def kind_of?(klass); end + + # Dispatches the method to the resolved object. + # + # @raise [ProxyMethodError] if the proxy cannot find the real object + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:178 + def method_missing(meth, *args, &block); end + + # The name of the object + # + # @param prefix [Boolean] whether to show a prefix. Implement + # this in a subclass to define how the prefix is showed. + # @return [Symbol] if prefix is false, the symbolized name + # @return [String] if prefix is true, prefix + the name as a String. + # This must be implemented by the subclass. + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:85 + def name(prefix = T.unsafe(nil)); end + + # Returns the value of attribute namespace. + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:27 + def namespace; end + + # Returns the value of attribute namespace. + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:27 + def parent; end + + # If the proxy resolves to an object, returns its path, otherwise + # guesses at the correct path using the original namespace and name. + # + # @return [String] the assumed path of the proxy (or the real path + # of the resolved object) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:100 + def path; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:171 + def respond_to?(meth, include_private = T.unsafe(nil)); end + + # This class is never a root object + # + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:200 + def root?; end + + # If the proxy resolves to an object, returns its path, otherwise + # guesses at the correct path using the original namespace and name. + # + # @return [String] the assumed path of the proxy (or the real path + # of the resolved object) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:100 + def title; end + + # If the proxy resolves to an object, returns its path, otherwise + # guesses at the correct path using the original namespace and name. + # + # @return [String] the assumed path of the proxy (or the real path + # of the resolved object) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:100 + def to_s; end + + # If the proxy resolves to an object, returns its path, otherwise + # guesses at the correct path using the original namespace and name. + # + # @return [String] the assumed path of the proxy (or the real path + # of the resolved object) + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:100 + def to_str; end + + # Returns the type of the proxy. If it cannot be resolved at the + # time of the call, it will either return the inferred proxy type + # (see {#type=}) or +:proxy+ + # + # @return [Symbol] the Proxy's type + # @see #type= + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:151 + def type; end + + # Allows a parser to infer the type of the proxy by its path. + # + # @param type [#to_sym] the proxy's inferred type + # @return [void] + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:158 + def type=(type); end + + private + + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:228 + def proxy_path; end + + # @note this method fixes a bug in 1.9.2: http://gist.github.com/437136 + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:205 + def to_ary; end + + # Attempts to find the object that this unresolved object + # references by checking if any objects by this name are + # registered all the way up the namespace tree. + # + # @return [Base, nil] the registered code object or nil + # + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:212 + def to_obj; end + + class << self + # source://yard-0.9.28/lib/yard/code_objects/proxy.rb:25 + def ===(other); end + end +end + +# A special type of +NoMethodError+ when raised from a {Proxy} +# +# source://yard-0.9.28/lib/yard/code_objects/proxy.rb:5 +class YARD::CodeObjects::ProxyMethodError < ::NoMethodError; end + +# Represents the root namespace object (the invisible Ruby module that +# holds all top level modules, class and other objects). +# +# source://yard-0.9.28/lib/yard/code_objects/root_object.rb:6 +class YARD::CodeObjects::RootObject < ::YARD::CodeObjects::ModuleObject + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:12 + def equal?(other); end + + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:16 + def hash; end + + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:8 + def inspect; end + + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:7 + def path; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:9 + def root?; end + + # source://yard-0.9.28/lib/yard/code_objects/root_object.rb:10 + def title; end +end + +# This class maintains all system-wide configuration for YARD and handles +# the loading of plugins. To access options call {options}, and to load +# a plugin use {load_plugin}. All other public methods are used by YARD +# during load time. +# +# == User Configuration Files +# +# Persistent user configuration files can be stored in the file +# +~/.yard/config+, which is read when YARD first loads. The file should +# be formatted as YAML, and should contain a map of keys and values. +# +# Although you can specify any key-value mapping in the configuration file, +# YARD defines special keys specified in {DEFAULT_CONFIG_OPTIONS}. +# +# An example of a configuration file is listed below: +# +# !!!yaml +# load_plugins: true # Auto-load plugins when YARD starts +# ignored_plugins: +# - yard-broken +# - broken2 # yard- prefix not necessary +# autoload_plugins: +# - yard-rspec +# +# == Automatic Loading of Plugins +# +# YARD 0.6.2 will no longer automatically load all plugins by default. This +# option can be reset by setting 'load_plugins' to true in the configuration +# file. In addition, you can specify a set of specific plugins to load on +# load through the 'autoload_plugins' list setting. This setting is +# independent of the 'load_plugins' value and will always be processed. +# +# == Ignored Plugins File +# +# YARD 0.5 and below used a +~/.yard/ignored_plugins+ file to specify +# plugins to be ignored at load time. Ignored plugins in 0.6.2 and above +# should now be specified in the main configuration file, though YARD +# will support the +ignored_plugins+ file until 0.7.x. +# +# == Safe Mode +# +# YARD supports running in safe-mode. By doing this, it will avoid executing +# any user code such as require files or queries. Plugins will still be +# loaded with safe mode on, because plugins are properly namespaced with +# a 'yard-' prefix, must be installed as a gem, and therefore cannot be +# touched by the user. To specify safe mode, use the +safe_mode+ key. +# +# == Plugin Specific Configuration +# +# Additional settings can be defined within the configuration file +# specifically to provide configuration for a plugin. A plugin that utilizes +# the YARD configuration is strongly encouraged to utilize namespacing of +# their configuration content. +# +# !!!yaml +# load_plugins: true # Auto-load plugins when YARD starts +# ignored_plugins: +# - yard-broken +# - broken2 # yard- prefix not necessary +# autoload_plugins: +# - yard-rspec +# # Plugin Specific Configuration +# yard-sample-plugin: +# show-results-inline: true +# +# As the configuration is available system wide, it can be +# accessed within the plugin code. +# +# +# if YARD::Config.options['yard-sample-plugin'] and +# YARD::Config.options['yard-sample-plugin']['show-results-inline'] +# # ... perform the action that places the results inline ... +# else +# # ... do the default behavior of not showing the results inline ... +# end +# +# When accessing the configuration, be aware that this file is user managed +# so configuration keys and values may not be present. Make no assumptions and +# instead ensure that you check for the existence of keys before proceeding to +# retrieve values. +# +# @see options +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:86 +class YARD::Config + class << self + # Legacy support for {IGNORED_PLUGINS} + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:221 + def add_ignored_plugins_file; end + + # @return [Array<String>] arguments from commandline and yardopts file + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:268 + def arguments; end + + # Loads settings from {CONFIG_FILE}. This method is called by YARD at + # load time and should not be called by the user. + # + # @return [void] + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:119 + def load; end + + # Load plugins set in :autoload_plugins + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:189 + def load_autoload_plugins; end + + # Load plugins from {arguments} + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:194 + def load_commandline_plugins; end + + # Check for command-line safe_mode switch in {arguments} + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:204 + def load_commandline_safemode; end + + # Load gem plugins if :load_plugins is true + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:169 + def load_gem_plugins; end + + # Loads an individual plugin by name. It is not necessary to include the + # +yard-+ plugin prefix here. + # + # @param name [String] the name of the plugin (with or without +yard-+ prefix) + # @return [Boolean] whether the plugin was successfully loaded + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:157 + def load_plugin(name); end + + # Print a warning if the plugin failed to load + # + # @return [false] + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:214 + def load_plugin_failed(name, exception); end + + # Loads gems that match the name 'yard-*' (recommended) or 'yard_*' except + # those listed in +~/.yard/ignored_plugins+. This is called immediately + # after YARD is loaded to allow plugin support. + # + # @return [Boolean] true if all plugins loaded successfully, false otherwise. + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:146 + def load_plugins; end + + # The system-wide configuration options for YARD + # + # @return [SymbolHash] a map a key-value pair settings. + # @see DEFAULT_CONFIG_OPTIONS + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:91 + def options; end + + # The system-wide configuration options for YARD + # + # @return [SymbolHash] a map a key-value pair settings. + # @see DEFAULT_CONFIG_OPTIONS + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:91 + def options=(_arg0); end + + # Loads the YAML configuration file into memory + # + # @return [Hash] the contents of the YAML file from disk + # @see CONFIG_FILE + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:236 + def read_config_file; end + + # Saves settings to {CONFIG_FILE}. + # + # @return [void] + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:135 + def save; end + + # Sanitizes and normalizes a plugin name to include the 'yard-' prefix. + # + # @param name [String] the plugin name + # @return [String] the sanitized and normalized plugin name. + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:252 + def translate_plugin_name(name); end + + # Translates plugin names to add yard- prefix. + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:228 + def translate_plugin_names; end + + # Temporarily loads .yardopts file into @yardopts + # + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/config.rb:259 + def with_yardopts; end + end +end + +# The location where YARD stores user-specific settings +# +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:95 +YARD::Config::CONFIG_DIR = T.let(T.unsafe(nil), String) + +# The main configuration YAML file. +# +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:98 +YARD::Config::CONFIG_FILE = T.let(T.unsafe(nil), String) + +# Default configuration options +# +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:105 +YARD::Config::DEFAULT_CONFIG_OPTIONS = T.let(T.unsafe(nil), Hash) + +# File listing all ignored plugins +# +# @deprecated Set `ignored_plugins` in the {CONFIG_FILE} instead. +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:102 +YARD::Config::IGNORED_PLUGINS = T.let(T.unsafe(nil), String) + +# The prefix used for YARD plugins. Name your gem with this prefix +# to allow it to be used as a plugin. +# +# @since 0.6.2 +# +# source://yard-0.9.28/lib/yard/config.rb:114 +YARD::Config::YARD_PLUGIN_PREFIX = T.let(T.unsafe(nil), Regexp) + +# A documentation string, or "docstring" for short, encapsulates the +# comments and metadata, or "tags", of an object. Meta-data is expressed +# in the form +@tag VALUE+, where VALUE can span over multiple lines as +# long as they are indented. The following +@example+ tag shows how tags +# can be indented: +# +# # @example My example +# # a = "hello world" +# # a.reverse +# # @version 1.0 +# +# Tags can be nested in a documentation string, though the {Tags::Tag} +# itself is responsible for parsing the inner tags. +# +# source://yard-0.9.28/lib/yard/docstring.rb:16 +class YARD::Docstring < ::String + # Creates a new docstring with the raw contents attached to an optional + # object. Parsing will be done by the {DocstringParser} class. + # + # @example + # Docstring.new("hello world\n@return Object return", someobj) + # @note To properly parse directives with proper parser context within + # handlers, you should not use this method to create a Docstring. + # Instead, use the {parser}, which takes a handler object that + # can pass parser state onto directives. If a Docstring is created + # with this method, directives do not have access to any parser + # state, and may not function as expected. + # @param content [String] the raw comments to be parsed into a docstring + # and associated meta-data. + # @param object [CodeObjects::Base] an object to associate the docstring + # with. + # @return [Docstring] a new instance of Docstring + # + # source://yard-0.9.28/lib/yard/docstring.rb:103 + def initialize(content = T.unsafe(nil), object = T.unsafe(nil)); end + + # Adds another {Docstring}, copying over tags. + # + # @param other [Docstring, String] the other docstring (or string) to + # add. + # @return [Docstring] a new docstring with both docstrings combines + # + # source://yard-0.9.28/lib/yard/docstring.rb:116 + def +(other); end + + # Adds a tag or reftag object to the tag list. If you want to parse + # tag data based on the {Tags::DefaultFactory} tag factory, use + # {DocstringParser} instead. + # + # @param tags [Tags::Tag, Tags::RefTag] list of tag objects to add + # @return [void] + # + # source://yard-0.9.28/lib/yard/docstring.rb:242 + def add_tag(*tags); end + + # @return [String] the raw documentation (including raw tag text) + # + # source://yard-0.9.28/lib/yard/docstring.rb:53 + def all; end + + # Replaces the docstring with new raw content. Called by {#all=}. + # + # @param content [String] the raw comments to be parsed + # + # source://yard-0.9.28/lib/yard/docstring.rb:132 + def all=(content, parse = T.unsafe(nil)); end + + # Returns true if the docstring has no content that is visible to a template. + # + # @param only_visible_tags [Boolean] whether only {Tags::Library.visible_tags} + # should be checked, or if all tags should be considered. + # @return [Boolean] whether or not the docstring has content + # + # source://yard-0.9.28/lib/yard/docstring.rb:310 + def blank?(only_visible_tags = T.unsafe(nil)); end + + # Deletes all tags where the block returns true + # + # @return [void] + # @since 0.7.0 + # @yieldparam tag [Tags::Tag] the tag that is being tested + # @yieldreturn [Boolean] true if the tag should be deleted + # + # source://yard-0.9.28/lib/yard/docstring.rb:300 + def delete_tag_if(&block); end + + # Delete all tags with +name+ + # + # @param name [String] the tag name + # @return [void] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/docstring.rb:291 + def delete_tags(name); end + + # Deep-copies a docstring + # + # @note This method creates a new docstring with new tag lists, but does + # not create new individual tags. Modifying the tag objects will still + # affect the original tags. + # @return [Docstring] a new copied docstring + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/docstring.rb:153 + def dup; end + + # Returns true if at least one tag by the name +name+ was declared + # + # @param name [String] the tag name to search for + # @return [Boolean] whether or not the tag +name+ was declared + # + # source://yard-0.9.28/lib/yard/docstring.rb:283 + def has_tag?(name); end + + # @return [Boolean] whether the docstring was started with "##" + # + # source://yard-0.9.28/lib/yard/docstring.rb:56 + def hash_flag; end + + # source://yard-0.9.28/lib/yard/docstring.rb:57 + def hash_flag=(v); end + + # @return [Fixnum] the first line of the {#line_range} + # @return [nil] if there is no associated {#line_range} + # + # source://yard-0.9.28/lib/yard/docstring.rb:167 + def line; end + + # @return [Range] line range in the {#object}'s file where the docstring was parsed from + # + # source://yard-0.9.28/lib/yard/docstring.rb:50 + def line_range; end + + # @return [Range] line range in the {#object}'s file where the docstring was parsed from + # + # source://yard-0.9.28/lib/yard/docstring.rb:50 + def line_range=(_arg0); end + + # @return [CodeObjects::Base] the object that owns the docstring. + # + # source://yard-0.9.28/lib/yard/docstring.rb:47 + def object; end + + # @return [CodeObjects::Base] the object that owns the docstring. + # + # source://yard-0.9.28/lib/yard/docstring.rb:47 + def object=(_arg0); end + + # @return [Array<Tags::RefTag>] the list of reference tags + # + # source://yard-0.9.28/lib/yard/docstring.rb:44 + def ref_tags; end + + # Replaces the docstring with new raw content. Called by {#all=}. + # + # @param content [String] the raw comments to be parsed + # + # source://yard-0.9.28/lib/yard/docstring.rb:132 + def replace(content, parse = T.unsafe(nil)); end + + # Resolves unresolved other docstring reference if there is + # unresolved reference. Does nothing if there is no unresolved + # reference. + # + # Normally, you don't need to call this method + # explicitly. Resolving unresolved reference is done implicitly. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/docstring.rb:328 + def resolve_reference; end + + # Gets the first line of a docstring to the period or the first paragraph. + # + # @return [String] The first line or paragraph of the docstring; always ends with a period. + # + # source://yard-0.9.28/lib/yard/docstring.rb:173 + def summary; end + + # Convenience method to return the first tag + # object in the list of tag objects of that name + # + # @example + # doc = Docstring.new("@return zero when nil") + # doc.tag(:return).text # => "zero when nil" + # @param name [#to_s] the tag name to return data for + # @return [Tags::Tag] the first tag in the list of {#tags} + # + # source://yard-0.9.28/lib/yard/docstring.rb:265 + def tag(name); end + + # Returns a list of tags specified by +name+ or all tags if +name+ is not specified. + # + # @param name [#to_s] the tag name to return data for, or nil for all tags + # @return [Array<Tags::Tag>] the list of tags by the specified tag name + # + # source://yard-0.9.28/lib/yard/docstring.rb:273 + def tags(name = T.unsafe(nil)); end + + # Reformats and returns a raw representation of the tag data using the + # current tag and docstring data, not the original text. + # + # @return [String] the updated raw formatted docstring data + # @since 0.7.0 + # @todo Add Tags::Tag#to_raw and refactor + # + # source://yard-0.9.28/lib/yard/docstring.rb:207 + def to_raw; end + + # source://yard-0.9.28/lib/yard/docstring.rb:125 + def to_s; end + + private + + # Maps valid reference tags + # + # @return [Array<Tags::RefTag>] the list of valid reference tags + # + # source://yard-0.9.28/lib/yard/docstring.rb:344 + def convert_ref_tags; end + + # Parses out comments split by newlines into a new code object + # + # @param comments [String] the newline delimited array of comments. If the comments + # are passed as a String, they will be split by newlines. + # @return [String] the non-metadata portion of the comments to + # be used as a docstring + # + # source://yard-0.9.28/lib/yard/docstring.rb:369 + def parse_comments(comments); end + + # A stable sort_by method. + # + # @param list [Enumerable] the list to sort. + # @return [Array] a stable sorted list. + # + # source://yard-0.9.28/lib/yard/docstring.rb:382 + def stable_sort_by(list); end + + class << self + # @note Plugin developers should make sure to reset this value + # after parsing finishes. This can be done via the + # {Parser::SourceParser.after_parse_list} callback. This will + # ensure that YARD can properly parse multiple projects in + # the same process. + # @return [Class<DocstringParser>] the parser class used to parse + # text and optional meta-data from docstrings. Defaults to + # {DocstringParser}. + # @see DocstringParser + # @see Parser::SourceParser.after_parse_list + # + # source://yard-0.9.28/lib/yard/docstring.rb:28 + def default_parser; end + + # @note Plugin developers should make sure to reset this value + # after parsing finishes. This can be done via the + # {Parser::SourceParser.after_parse_list} callback. This will + # ensure that YARD can properly parse multiple projects in + # the same process. + # @return [Class<DocstringParser>] the parser class used to parse + # text and optional meta-data from docstrings. Defaults to + # {DocstringParser}. + # @see DocstringParser + # @see Parser::SourceParser.after_parse_list + # + # source://yard-0.9.28/lib/yard/docstring.rb:28 + def default_parser=(_arg0); end + + # Creates a new docstring without performing any parsing through + # a {DocstringParser}. This method is called by +DocstringParser+ + # when creating the new docstring object. + # + # @param text [String] the textual portion of the docstring + # @param tags [Array<Tags::Tag>] the list of tag objects in the docstring + # @param object [CodeObjects::Base, nil] the object associated with the + # docstring. May be nil. + # @param raw_data [String] the complete docstring, including all + # original formatting and any unparsed tags/directives. + # @param ref_object [CodeObjects::Base, nil] a reference object used for + # the base set of documentation / tag information. + # + # source://yard-0.9.28/lib/yard/docstring.rb:77 + def new!(text, tags = T.unsafe(nil), object = T.unsafe(nil), raw_data = T.unsafe(nil), ref_object = T.unsafe(nil)); end + + # Creates a parser object using the current {default_parser}. + # Equivalent to: + # Docstring.default_parser.new(*args) + # + # @param args arguments are passed to the {DocstringParser} + # class. See {DocstringParser#initialize} for details on + # arguments. + # @return [DocstringParser] the parser object used to parse a + # docstring. + # + # source://yard-0.9.28/lib/yard/docstring.rb:38 + def parser(*args); end + end +end + +# Matches a tag at the start of a comment line +# +# @deprecated Use {DocstringParser::META_MATCH} +# +# source://yard-0.9.28/lib/yard/docstring.rb:61 +YARD::Docstring::META_MATCH = T.let(T.unsafe(nil), Regexp) + +# Parses text and creates a {Docstring} object to represent documentation +# for a {CodeObjects::Base}. To create a new docstring, you should initialize +# the parser and call {#parse} followed by {#to_docstring}. +# +# == Subclassing Notes +# +# The DocstringParser can be subclassed and subtituted during parsing by +# setting the {Docstring.default_parser} attribute with the name of the +# subclass. This allows developers to change the way docstrings are +# parsed, allowing for completely different docstring syntaxes. +# +# @example Creating a Docstring with a DocstringParser +# DocstringParser.new.parse("text here").to_docstring +# @example Creating a Custom DocstringParser +# # Parses docstrings backwards! +# class ReverseDocstringParser +# def parse_content(content) +# super(content.reverse) +# end +# end +# +# # Set the parser as default when parsing +# YARD::Docstring.default_parser = ReverseDocstringParser +# @see #parse_content +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/docstring_parser.rb:30 +class YARD::DocstringParser + # Creates a new parser to parse docstring data + # + # @param library [Tags::Library] a tag library for recognizing + # tags. + # @return [DocstringParser] a new instance of DocstringParser + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:81 + def initialize(library = T.unsafe(nil)); end + + # Creates a new directive using the registered {#library} + # + # @return [Tags::Directive] the directive object that is created + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:232 + def create_directive(tag_name, tag_buf); end + + # Creates a {Tags::RefTag} + # + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:226 + def create_ref_tag(tag_name, name, object_name); end + + # Creates a tag from the {Tags::DefaultFactory tag factory}. + # + # To add an already created tag object, append it to {#tags}. + # + # @param tag_name [String] the tag name + # @param tag_buf [String] the text attached to the tag with newlines removed. + # @return [Tags::Tag, Tags::RefTag] a tag + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:209 + def create_tag(tag_name, tag_buf = T.unsafe(nil)); end + + # @return [Array<Tags::Directive>] a list of directives identified + # by the parser. This list will not be passed on to the + # Docstring object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:45 + def directives; end + + # @return [Array<Tags::Directive>] a list of directives identified + # by the parser. This list will not be passed on to the + # Docstring object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:45 + def directives=(_arg0); end + + # @return [Handlers::Base, nil] the handler parsing this + # docstring. May be nil if this docstring parser is not + # initialized through + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:66 + def handler; end + + # @return [Handlers::Base, nil] the handler parsing this + # docstring. May be nil if this docstring parser is not + # initialized through + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:66 + def handler=(_arg0); end + + # @return [Tags::Library] the tag library being used to + # identify registered tags in the docstring. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:70 + def library; end + + # @return [Tags::Library] the tag library being used to + # identify registered tags in the docstring. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:70 + def library=(_arg0); end + + # @return [CodeObjects::Base, nil] the object associated with + # the docstring being parsed. May be nil if the docstring is + # not attached to any object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:56 + def object; end + + # @return [CodeObjects::Base, nil] the object associated with + # the docstring being parsed. May be nil if the docstring is + # not attached to any object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:56 + def object=(_arg0); end + + # Parses all content and returns itself. + # + # @param content [String] the docstring text to parse + # @param object [CodeObjects::Base] the object that the docstring + # is attached to. Will be passed to directives to act on + # this object. + # @param handler [Handlers::Base, nil] the handler object that is + # parsing this object. May be nil if this parser is not being + # called from a {Parser::SourceParser} context. + # @return [self] the parser object. To get the docstring, + # call {#to_docstring}. + # @see #to_docstring + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:113 + def parse(content, object = T.unsafe(nil), handler = T.unsafe(nil)); end + + # Parses a given block of text. + # + # @note Subclasses can override this method to perform custom + # parsing of content data. + # @param content [String] the content to parse + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:129 + def parse_content(content); end + + # Call post processing callbacks on parser. + # This is called implicitly by parser. Use this when + # manually configuring a {Docstring} object. + # + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:196 + def post_process; end + + # @return [String] the complete input string to the parser. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:36 + def raw_text; end + + # @return [String] the complete input string to the parser. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:36 + def raw_text=(_arg0); end + + # @return [CodeObjects::Base, nil] the object referenced by + # the docstring being parsed. May be nil if the docstring doesn't + # refer to any object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:61 + def reference; end + + # @return [CodeObjects::Base, nil] the object referenced by + # the docstring being parsed. May be nil if the docstring doesn't + # refer to any object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:61 + def reference=(_arg0); end + + # @return [OpenStruct] any arbitrary state to be passed between + # tags during parsing. Mainly used by directives to coordinate + # behaviour (so that directives can be aware of other directives + # used in a docstring). + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:51 + def state; end + + # @return [OpenStruct] any arbitrary state to be passed between + # tags during parsing. Mainly used by directives to coordinate + # behaviour (so that directives can be aware of other directives + # used in a docstring). + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:51 + def state=(_arg0); end + + # Backward compatibility to detect old tags that should be specified + # as directives in 0.8 and onward. + # + # @return [Boolean] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:252 + def tag_is_directive?(tag_name); end + + # @return [Array<Tags::Tag>] the list of meta-data tags identified + # by the parser + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:40 + def tags; end + + # @return [Array<Tags::Tag>] the list of meta-data tags identified + # by the parser + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:40 + def tags=(_arg0); end + + # @return [String] the parsed text portion of the docstring, + # with tags removed. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:33 + def text; end + + # @return [String] the parsed text portion of the docstring, + # with tags removed. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:33 + def text=(_arg0); end + + # @return [Docstring] translates parsed text into + # a Docstring object. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:95 + def to_docstring; end + + private + + # Calls all {after_parse} callbacks + # + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:324 + def call_after_parse_callbacks; end + + # Calls the {Tags::Directive#after_parse} callback on all the + # created directives. + # + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:319 + def call_directives_after_parse; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:305 + def detect_reference(content); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:301 + def namespace; end + + class << self + # Creates a callback that is called after a docstring is successfully + # parsed. Use this method to perform sanity checks on a docstring's + # tag data, or add any extra tags automatically to a docstring. + # + # @return [void] + # @since 0.8.0 + # @yield [parser] a block to be called after a docstring is parsed + # @yieldparam parser [DocstringParser] the docstring parser object + # with all directives and tags created. + # @yieldreturn [void] + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:266 + def after_parse(&block); end + + # @return [Array<Proc>] the {after_parse} callback proc objects + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/docstring_parser.rb:271 + def after_parse_callbacks; end + end +end + +# The regular expression to match the tag syntax +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/docstring_parser.rb:73 +YARD::DocstringParser::META_MATCH = T.let(T.unsafe(nil), Regexp) + +# source://yard-0.9.28/lib/yard/gem_index.rb:6 +module YARD::GemIndex + private + + # source://yard-0.9.28/lib/yard/gem_index.rb:25 + def all; end + + # source://yard-0.9.28/lib/yard/gem_index.rb:17 + def each(&block); end + + # source://yard-0.9.28/lib/yard/gem_index.rb:9 + def find_all_by_name(*args); end + + class << self + # source://yard-0.9.28/lib/yard/gem_index.rb:25 + def all; end + + # source://yard-0.9.28/lib/yard/gem_index.rb:17 + def each(&block); end + + # source://yard-0.9.28/lib/yard/gem_index.rb:9 + def find_all_by_name(*args); end + end +end + +# Handlers are called during the data processing part of YARD's +# parsing phase. This allows YARD as well as any custom extension to +# analyze source and generate {CodeObjects} to be stored for later use. +# +# source://yard-0.9.28/lib/yard/autoload.rb:66 +module YARD::Handlers; end + +# Handlers are pluggable semantic parsers for YARD's code generation +# phase. They allow developers to control what information gets +# generated by YARD, giving them the ability to, for instance, document +# any Ruby DSLs that a customized framework may use. A good example +# of this would be the ability to document and generate meta data for +# the 'describe' declaration of the RSpec testing framework by simply +# adding a handler for such a keyword. Similarly, any Ruby API that +# takes advantage of class level declarations could add these to the +# documentation in a very explicit format by treating them as first- +# class objects in any outputted documentation. +# +# == Overview of a Typical Handler Scenario +# +# Generally, a handler class will declare a set of statements which +# it will handle using the {handles} class declaration. It will then +# implement the {#process} method to do the work. The processing would +# usually involve the manipulation of the {#namespace}, {#owner} +# {CodeObjects::Base code objects} or the creation of new ones, in +# which case they should be registered by {#register}, a method that +# sets some basic attributes for the new objects. +# +# Handlers are usually simple and take up to a page of code to process +# and register a new object or add new attributes to the current +namespace+. +# +# == Setting up a Handler for Use +# +# A Handler is automatically registered when it is subclassed from the +# base class. The only other thing that needs to be done is to specify +# which statement the handler will process. This is done with the +handles+ +# declaration, taking either a {Parser::Ruby::Legacy::RubyToken}, {String} or `Regexp`. +# Here is a simple example which processes module statements. +# +# class MyModuleHandler < YARD::Handlers::Base +# handles TkMODULE +# +# def process +# # do something +# end +# end +# +# == Processing Handler Data +# +# The goal of a specific handler is really up to the developer, and as +# such there is no real guideline on how to process the data. However, +# it is important to know where the data is coming from to be able to use +# it. +# +# === +statement+ Attribute +# +# The +statement+ attribute pertains to the {Parser::Ruby::Legacy::Statement} object +# containing a set of tokens parsed in by the parser. This is the main set +# of data to be analyzed and processed. The comments attached to the statement +# can be accessed by the {Parser::Ruby::Legacy::Statement#comments} method, but generally +# the data to be processed will live in the +tokens+ attribute. This list +# can be converted to a +String+ using +#to_s+ to parse the data with +# regular expressions (or other text processing mechanisms), if needed. +# +# === +namespace+ Attribute +# +# The +namespace+ attribute is a {CodeObjects::NamespaceObject namespace object} +# which represents the current namespace that the parser is in. For instance: +# +# module SomeModule +# class MyClass +# def mymethod; end +# end +# end +# +# If a handler was to parse the 'class MyClass' statement, it would +# be necessary to know that it belonged inside the SomeModule module. +# This is the value that +namespace+ would return when processing such +# a statement. If the class was then entered and another handler was +# called on the method, the +namespace+ would be set to the 'MyClass' +# code object. +# +# === +owner+ Attribute +# +# The +owner+ attribute is similar to the +namespace+ attribute in that +# it also follows the scope of the code during parsing. However, a namespace +# object is loosely defined as a module or class and YARD has the ability +# to parse beyond module and class blocks (inside methods, for instance), +# so the +owner+ attribute would not be limited to modules and classes. +# +# To put this into context, the example from above will be used. If a method +# handler was added to the mix and decided to parse inside the method body, +# the +owner+ would be set to the method object but the namespace would remain +# set to the class. This would allow the developer to process any method +# definitions set inside a method (def x; def y; 2 end end) by adding them +# to the correct namespace (the class, not the method). +# +# In summary, the distinction between +namespace+ and +owner+ can be thought +# of as the difference between first-class Ruby objects (namespaces) and +# second-class Ruby objects (methods). +# +# === +visibility+ and +scope+ Attributes +# +# Mainly needed for parsing methods, the +visibility+ and +scope+ attributes +# refer to the public/protected/private and class/instance values (respectively) +# of the current parsing position. +# +# == Parsing Blocks in Statements +# +# In addition to parsing a statement and creating new objects, some +# handlers may wish to continue parsing the code inside the statement's +# block (if there is one). In this context, a block means the inside +# of any statement, be it class definition, module definition, if +# statement or classic 'Ruby block'. +# +# For example, a class statement would be "class MyClass" and the block +# would be a list of statements including the method definitions inside +# the class. For a class handler, the programmer would execute the +# {#parse_block} method to continue parsing code inside the block, with +# the +namespace+ now pointing to the class object the handler created. +# +# YARD has the ability to continue into any block: class, module, method, +# even if statements. For this reason, the block parsing method must be +# invoked explicitly out of efficiency sake. +# +# @abstract Subclass this class to provide a handler for YARD to use +# during the processing phase. +# @see CodeObjects::Base +# @see CodeObjects::NamespaceObject +# @see handles +# @see #namespace +# @see #owner +# @see #register +# @see #parse_block +# +# source://yard-0.9.28/lib/yard/handlers/base.rb:149 +class YARD::Handlers::Base + include ::YARD::CodeObjects + include ::YARD::Parser + + # @return [Base] a new instance of Base + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:276 + def initialize(source_parser, stmt); end + + # Aborts a handler by raising {Handlers::HandlerAborted}. + # An exception will only be logged in debugging mode for + # this kind of handler exit. + # + # @raise [Handlers::HandlerAborted] + # @since 0.8.4 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:355 + def abort!; end + + # @abstract Implement this method to return the parameters in a method call + # statement. It should return an empty list if the statement is not a + # method call. + # @raise [NotImplementedError] + # @return [Array<String>] a list of argument names + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:581 + def call_params; end + + # @abstract Implement this method to return the method being called in + # a method call. It should return nil if the statement is not a method + # call. + # @raise [NotImplementedError] + # @return [String] the method name being called + # @return [nil] if the statement is not a method call + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:590 + def caller_method; end + + # Ensures that a specific +object+ has been parsed and loaded into the + # registry. This is necessary when adding data to a namespace, for instance, + # since the namespace may not have been processed yet (it can be located + # in a file that has not been handled). + # + # Calling this method defers the handler until all other files have been + # processed. If the object gets resolved, the rest of the handler continues, + # otherwise an exception is raised. + # + # @example Adding a mixin to the String class programmatically + # ensure_loaded! P('String') + # # "String" is now guaranteed to be loaded + # P('String').mixins << P('MyMixin') + # @param object [Proxy, CodeObjects::Base] the object to resolve. + # @param max_retries [Integer] the number of times to defer the handler + # before raising a +NamespaceMissingError+. + # @raise [NamespaceMissingError] if the object is not resolved within + # +max_retries+ attempts, this exception is raised and the handler + # finishes processing. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:561 + def ensure_loaded!(object, max_retries = T.unsafe(nil)); end + + # Returns the value of attribute extra_state. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:348 + def extra_state; end + + # Returns the value of attribute globals. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:347 + def globals; end + + # Returns the value of attribute namespace. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:341 + def namespace; end + + # Sets the attribute namespace + # + # @param value the value to set the attribute namespace to. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:342 + def namespace=(v); end + + # Returns the value of attribute owner. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:339 + def owner; end + + # Sets the attribute owner + # + # @param value the value to set the attribute owner to. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:340 + def owner=(v); end + + # Parses the semantic "block" contained in the statement node. + # + # @abstract Subclasses should call {Processor#process parser.process} + # @raise [NotImplementedError] + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:304 + def parse_block(*_arg0); end + + # @return [Processor] the processor object that manages all global state + # during handling. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:310 + def parser; end + + # The main handler method called by the parser on a statement + # that matches the {handles} declaration. + # + # Subclasses should override this method to provide the handling + # functionality for the class. + # + # @raise [NotImplementedError] + # @return [Array<CodeObjects::Base>, CodeObjects::Base, Object] If this method returns a code object (or a list of them), + # they are passed to the +#register+ method which adds basic + # attributes. It is not necessary to return any objects and in + # some cases you may want to explicitly avoid the returning of + # any objects for post-processing by the register method. + # @see handles + # @see #register + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:297 + def process; end + + # Executes a given block with specific state values for {#owner}, + # {#namespace} and {#scope}. + # + # @option opts + # @option opts + # @option opts + # @param opts [Hash] a customizable set of options + # @yield a block to execute with the given state values. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:370 + def push_state(opts = T.unsafe(nil)); end + + # Do some post processing on a list of code objects. + # Adds basic attributes to the list of objects like + # the filename, line number, {CodeObjects::Base#dynamic}, + # source code and {CodeObjects::Base#docstring}, + # but only if they don't exist. + # + # @param objects [Array<CodeObjects::Base>] the list of objects to post-process. + # @return [CodeObjects::Base, Array<CodeObjects::Base>] returns whatever is passed in, for chainability. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:407 + def register(*objects); end + + # Registers any docstring found for the object and expands macros + # + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:450 + def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end + + # Registers the object as dynamic if the object is defined inside + # a method or block (owner != namespace) + # + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:537 + def register_dynamic(object); end + + # Ensures that the object's namespace is loaded before attaching it + # to the namespace. + # + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:429 + def register_ensure_loaded(object); end + + # Registers the file/line of the declaration with the object + # + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:441 + def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end + + # Registers the object as being inside a specific group + # + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:473 + def register_group(object, group = T.unsafe(nil)); end + + # Registers the same method information on the module function, if + # the object was defined as a module function. + # + # @param object [CodeObjects::Base] the possible module function object + # to copy data for + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:523 + def register_module_function(object); end + + # @param object [CodeObjects::Base] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:499 + def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end + + # Registers any transitive tags from the namespace on the object + # + # @param object [CodeObjects::Base, nil] the object to register + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:487 + def register_transitive_tags(object); end + + # Registers visibility on a method object. If the object does not + # respond to setting visibility, nothing is done. + # + # @param object [#visibility=] the object to register + # @param visibility [Symbol] the visibility to set on the object + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:511 + def register_visibility(object, visibility = T.unsafe(nil)); end + + # Returns the value of attribute scope. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:345 + def scope; end + + # Sets the attribute scope + # + # @param value the value to set the attribute scope to. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:346 + def scope=(v); end + + # @return [Object] the statement object currently being processed. Usually + # refers to one semantic language statement, though the strict definition + # depends on the parser used. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:315 + def statement; end + + # Returns the value of attribute visibility. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:343 + def visibility; end + + # Sets the attribute visibility + # + # @param value the value to set the attribute visibility to. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:344 + def visibility=(v); end + + class << self + # Clear all registered subclasses. Testing purposes only + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:159 + def clear_subclasses; end + + # @return [Array] a list of matchers for the handler object. + # @see handles? + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:211 + def handlers; end + + # Declares the statement type which will be processed + # by this handler. + # + # A match need not be unique to a handler. Multiple + # handlers can process the same statement. However, + # in this case, care should be taken to make sure that + # {#parse_block} would only be executed by one of + # the handlers, otherwise the same code will be parsed + # multiple times and slow YARD down. + # + # @param matches [Parser::Ruby::Legacy::RubyToken, Symbol, String, Regexp] statements that match the declaration will be + # processed by this handler. A {String} match is + # equivalent to a +/\Astring/+ regular expression + # (match from the beginning of the line), and all + # token matches match only the first token of the + # statement. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:192 + def handles(*matches); end + + # This class is implemented by {Ruby::Base} and {Ruby::Legacy::Base}. + # To implement a base handler class for another language, implement + # this method to return true if the handler should process the given + # statement object. Use {handlers} to enumerate the matchers declared + # for the handler class. + # + # @param statement a statement object or node (depends on language type) + # @raise [NotImplementedError] + # @return [Boolean] whether or not this handler object should process + # the given statement + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:205 + def handles?(statement); end + + # Declares that a handler should only be called when inside a filename + # by its basename or a regex match for the full path. + # + # @param filename [String, Regexp] a matching filename or regex + # @return [void] + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:235 + def in_file(filename); end + + # @private + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:169 + def inherited(subclass); end + + # @return [Boolean] whether the filename matches the declared file + # match for a handler. If no file match is specified, returns true. + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:242 + def matches_file?(filename); end + + # Declares that the handler should only be called when inside a + # {CodeObjects::NamespaceObject}, not a method body. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:219 + def namespace_only; end + + # @return [Boolean] whether the handler should only be processed inside + # a namespace. + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:225 + def namespace_only?; end + + # Generates a +process+ method, equivalent to +def process; ... end+. + # Blocks defined with this syntax will be wrapped inside an anonymous + # module so that the handler class can be extended with mixins that + # override the +process+ method without alias chaining. + # + # @return [void] + # @see #process + # @since 0.5.4 + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:269 + def process(&block); end + + # Returns all registered handler subclasses. + # + # @return [Array<Base>] a list of handlers + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:165 + def subclasses; end + end +end + +# CRuby Handlers +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/autoload.rb:74 +module YARD::Handlers::C; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/alias_handler.rb:2 +class YARD::Handlers::C::AliasHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/alias_handler.rb:3 +YARD::Handlers::C::AliasHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/attribute_handler.rb:2 +class YARD::Handlers::C::AttributeHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/attribute_handler.rb:3 +YARD::Handlers::C::AttributeHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/base.rb:5 +class YARD::Handlers::C::Base < ::YARD::Handlers::Base + include ::YARD::Parser::C + include ::YARD::Handlers::Common::MethodHandler + include ::YARD::Handlers::C::HandlerMethods + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:77 + def ensure_variable_defined!(var, max_retries = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:64 + def namespace_for_variable(var); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:94 + def namespaces; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:60 + def override_comments; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:104 + def parse_block(opts = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:113 + def process_file(file, object); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:98 + def processed_files; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:38 + def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:42 + def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:46 + def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:50 + def register_visibility(object, visibility = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:56 + def symbols; end + + private + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:158 + def remove_var_prefix(var); end + + class << self + # @return [Boolean] whether the handler handles this statement + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:10 + def handles?(statement, processor); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/base.rb:28 + def statement_class(type = T.unsafe(nil)); end + end +end + +# Generated by update_error_map.rb (Copy+past results) +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/base.rb:131 +YARD::Handlers::C::Base::ERROR_CLASS_NAMES = T.let(T.unsafe(nil), Hash) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/class_handler.rb:2 +class YARD::Handlers::C::ClassHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/class_handler.rb:3 +YARD::Handlers::C::ClassHandler::MATCH1 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/class_handler.rb:9 +YARD::Handlers::C::ClassHandler::MATCH2 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/constant_handler.rb:2 +class YARD::Handlers::C::ConstantHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/constant_handler.rb:3 +YARD::Handlers::C::ConstantHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:5 +module YARD::Handlers::C::HandlerMethods + include ::YARD::Parser::C + include ::YARD::CodeObjects + include ::YARD::Handlers::Common::MethodHandler + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:86 + def handle_alias(var_name, new_name, old_name); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:75 + def handle_attribute(var_name, name, read, write); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:10 + def handle_class(var_name, class_name, parent, in_module = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:109 + def handle_constants(type, var_name, const_name, value); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:46 + def handle_method(scope, var_name, name, func_name, _source_file = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:33 + def handle_module(var_name, module_name, in_module = T.unsafe(nil)); end + + private + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:123 + def find_constant_docstring(object); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:154 + def find_method_body(object, symbol); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/handler_methods.rb:196 + def record_parameters(object, symbol, src); end +end + +# Handles the Init_Libname() method +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/init_handler.rb:3 +class YARD::Handlers::C::InitHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/init_handler.rb:4 +YARD::Handlers::C::InitHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/method_handler.rb:2 +class YARD::Handlers::C::MethodHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/method_handler.rb:3 +YARD::Handlers::C::MethodHandler::MATCH1 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/method_handler.rb:14 +YARD::Handlers::C::MethodHandler::MATCH2 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/method_handler.rb:18 +YARD::Handlers::C::MethodHandler::MATCH3 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/mixin_handler.rb:2 +class YARD::Handlers::C::MixinHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/mixin_handler.rb:3 +YARD::Handlers::C::MixinHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/module_handler.rb:2 +class YARD::Handlers::C::ModuleHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/module_handler.rb:3 +YARD::Handlers::C::ModuleHandler::MATCH1 = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/module_handler.rb:4 +YARD::Handlers::C::ModuleHandler::MATCH2 = T.let(T.unsafe(nil), Regexp) + +# Parses comments +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/override_comment_handler.rb:3 +class YARD::Handlers::C::OverrideCommentHandler < ::YARD::Handlers::C::Base + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/override_comment_handler.rb:24 + def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/handlers/c/override_comment_handler.rb:28 + def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end +end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/path_handler.rb:2 +class YARD::Handlers::C::PathHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/path_handler.rb:3 +YARD::Handlers::C::PathHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/struct_handler.rb:2 +class YARD::Handlers::C::StructHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/struct_handler.rb:3 +YARD::Handlers::C::StructHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# Keeps track of function bodies for symbol lookup during Ruby method declarations +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/symbol_handler.rb:3 +class YARD::Handlers::C::SymbolHandler < ::YARD::Handlers::C::Base; end + +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/handlers/c/symbol_handler.rb:4 +YARD::Handlers::C::SymbolHandler::MATCH = T.let(T.unsafe(nil), Regexp) + +# Shared logic between C and Ruby handlers. +# +# source://yard-0.9.28/lib/yard/autoload.rb:68 +module YARD::Handlers::Common; end + +# Shared functionality between Ruby and C method handlers. +# +# source://yard-0.9.28/lib/yard/handlers/common/method_handler.rb:6 +module YARD::Handlers::Common::MethodHandler + # @param obj [MethodObject] + # + # source://yard-0.9.28/lib/yard/handlers/common/method_handler.rb:8 + def add_predicate_return_tag(obj); end +end + +# Raise this error when a handler should exit before completing. +# The exception will be silenced, allowing the next handler(s) in the +# queue to be executed. +# +# @since 0.8.4 +# +# source://yard-0.9.28/lib/yard/handlers/base.rb:8 +class YARD::Handlers::HandlerAborted < ::RuntimeError; end + +# Raised during processing phase when a handler needs to perform +# an operation on an object's namespace but the namespace could +# not be resolved. +# +# source://yard-0.9.28/lib/yard/handlers/base.rb:15 +class YARD::Handlers::NamespaceMissingError < ::YARD::Parser::UndocumentableError + # @return [NamespaceMissingError] a new instance of NamespaceMissingError + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:18 + def initialize(object); end + + # The object the error occurred on + # + # @return [CodeObjects::Base] a code object + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:16 + def object; end + + # The object the error occurred on + # + # @return [CodeObjects::Base] a code object + # + # source://yard-0.9.28/lib/yard/handlers/base.rb:16 + def object=(_arg0); end +end + +# Iterates over all statements in a file and delegates them to the +# {Handlers::Base} objects that are registered to handle the statement. +# +# This class is passed to each handler and keeps overall processing state. +# For example, if the {#visibility} is set in a handler, all following +# statements will have access to this state. This allows "public", +# "protected" and "private" statements to be handled in classes and modules. +# In addition, the {#namespace} can be set during parsing to control +# where objects are being created from. You can also access extra stateful +# properties that any handler can set during the duration of the post +# processing of a file from {#extra_state}. If you need to access state +# across different files, look at {#globals}. +# +# @see Handlers::Base +# +# source://yard-0.9.28/lib/yard/handlers/processor.rb:20 +class YARD::Handlers::Processor + # Creates a new Processor for a +file+. + # + # @param parser [Parser::SourceParser] the parser used to initialize the processor + # @return [Processor] a new instance of Processor + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:92 + def initialize(parser); end + + # Share state across different handlers inside of a file. + # This attribute is similar to {#visibility}, {#scope}, {#namespace} + # and {#owner}, in that they all maintain state across all handlers + # for the entire source file. Use this attribute to store any data + # your handler might need to save during the parsing of a file. If + # you need to save state across files, see {#globals}. + # + # @return [OpenStruct] an open structure that can store arbitrary data + # @see #globals + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:88 + def extra_state; end + + # Share state across different handlers inside of a file. + # This attribute is similar to {#visibility}, {#scope}, {#namespace} + # and {#owner}, in that they all maintain state across all handlers + # for the entire source file. Use this attribute to store any data + # your handler might need to save during the parsing of a file. If + # you need to save state across files, see {#globals}. + # + # @return [OpenStruct] an open structure that can store arbitrary data + # @see #globals + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:88 + def extra_state=(_arg0); end + + # @return [String] the filename + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:41 + def file; end + + # @return [String] the filename + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:41 + def file=(_arg0); end + + # Searches for all handlers in {Base.subclasses} that match the +statement+ + # + # @param statement the statement object to match. + # @return [Array<Base>] a list of handlers to process the statement with. + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:151 + def find_handlers(statement); end + + # Handlers can share state for the entire post processing stage through + # this attribute. Note that post processing stage spans multiple files. + # To share state only within a single file, use {#extra_state} + # + # @example Sharing state among two handlers + # class Handler1 < YARD::Handlers::Ruby::Base + # handles :class + # process { globals.foo = :bar } + # end + # + # class Handler2 < YARD::Handlers::Ruby::Base + # handles :method + # process { puts globals.foo } + # end + # @return [OpenStruct] global shared state for post-processing stage + # @see #extra_state + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:77 + def globals; end + + # Handlers can share state for the entire post processing stage through + # this attribute. Note that post processing stage spans multiple files. + # To share state only within a single file, use {#extra_state} + # + # @example Sharing state among two handlers + # class Handler1 < YARD::Handlers::Ruby::Base + # handles :class + # process { globals.foo = :bar } + # end + # + # class Handler2 < YARD::Handlers::Ruby::Base + # handles :method + # process { puts globals.foo } + # end + # @return [OpenStruct] global shared state for post-processing stage + # @see #extra_state + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:77 + def globals=(_arg0); end + + # @return [CodeObjects::NamespaceObject] the current namespace + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:44 + def namespace; end + + # @return [CodeObjects::NamespaceObject] the current namespace + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:44 + def namespace=(_arg0); end + + # @return [CodeObjects::Base, nil] unlike the namespace, the owner + # is a non-namespace object that should be stored between statements. + # For instance, when parsing a method body, the {CodeObjects::MethodObject} + # is set as the owner, in case any extra method information is processed. + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:56 + def owner; end + + # @return [CodeObjects::Base, nil] unlike the namespace, the owner + # is a non-namespace object that should be stored between statements. + # For instance, when parsing a method body, the {CodeObjects::MethodObject} + # is set as the owner, in case any extra method information is processed. + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:56 + def owner=(_arg0); end + + # Continue parsing the remainder of the files in the +globals.ordered_parser+ + # object. After the remainder of files are parsed, processing will continue + # on the current file. + # + # @return [void] + # @see Parser::OrderedParser + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:140 + def parse_remaining_files; end + + # @return [Symbol] the parser type (:ruby, :ruby18, :c) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:59 + def parser_type; end + + # @return [Symbol] the parser type (:ruby, :ruby18, :c) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:59 + def parser_type=(_arg0); end + + # Processes a list of statements by finding handlers to process each + # one. + # + # @param statements [Array] a list of statements + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:110 + def process(statements); end + + # @return [Symbol] the current scope (class, instance) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:50 + def scope; end + + # @return [Symbol] the current scope (class, instance) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:50 + def scope=(_arg0); end + + # @return [Symbol] the current visibility (public, private, protected) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:47 + def visibility; end + + # @return [Symbol] the current visibility (public, private, protected) + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:47 + def visibility=(_arg0); end + + private + + # Returns the handler base class + # + # @return [Base] the base class + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:172 + def handler_base_class; end + + # The module holding the handlers to be loaded + # + # @return [Module] the module containing the handlers depending on + # {#parser_type}. + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:180 + def handler_base_namespace; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:161 + def handles?(handler, statement); end + + # Loads handlers from {#handler_base_namespace}. This ensures that + # Ruby1.9 handlers are never loaded into 1.8; also lowers the amount + # of modules that are loaded + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:188 + def load_handlers; end + + class << self + # @private + # @return [Hash] a list of registered parser type extensions + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:33 + def namespace_for_handler; end + + # Registers a new namespace for handlers of the given type. + # + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/handlers/processor.rb:24 + def register_handler_namespace(type, ns); end + end +end + +# All Ruby handlers +# +# source://yard-0.9.28/lib/yard/autoload.rb:92 +module YARD::Handlers::Ruby; end + +# Handles alias and alias_method calls +# +# source://yard-0.9.28/lib/yard/handlers/ruby/alias_handler.rb:3 +class YARD::Handlers::Ruby::AliasHandler < ::YARD::Handlers::Ruby::Base; end + +# Handles +attr_*+ statements in modules/classes +# +# source://yard-0.9.28/lib/yard/handlers/ruby/attribute_handler.rb:3 +class YARD::Handlers::Ruby::AttributeHandler < ::YARD::Handlers::Ruby::Base + protected + + # Strips out any non-essential arguments from the attr statement. + # + # @param params [Array<Parser::Ruby::AstNode>] a list of the parameters + # in the attr call. + # @raise [Parser::UndocumentableError] if the arguments are not valid. + # @return [Array<String>] the validated attribute names + # + # source://yard-0.9.28/lib/yard/handlers/ruby/attribute_handler.rb:75 + def validated_attribute_names(params); end +end + +# This is the base handler class for the new-style (1.9) Ruby parser. +# All handlers that subclass this base class will be used when the +# new-style parser is used. For implementing legacy handlers, see +# {Legacy::Base}. +# +# @abstract See {Handlers::Base} for subclassing information. +# @see Handlers::Base +# @see Legacy::Base +# +# source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:65 +class YARD::Handlers::Ruby::Base < ::YARD::Handlers::Base + include ::YARD::Parser::Ruby + extend ::YARD::Parser::Ruby + + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:144 + def call_params; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:155 + def caller_method; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:135 + def parse_block(inner_node, opts = T.unsafe(nil)); end + + class << self + # @return [Boolean] whether or not an {AstNode} object should be + # handled by this handler + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:113 + def handles?(node); end + + # Matcher for handling a node with a specific meta-type. An {AstNode} + # has a {AstNode#type} to define its type but can also be associated + # with a set of types. For instance, +:if+ and +:unless+ are both + # of the meta-type +:condition+. + # + # A meta-type is any method on the {AstNode} class ending in "?", + # though you should not include the "?" suffix in your declaration. + # Some examples are: "condition", "call", "literal", "kw", "token", + # "ref". + # + # @example Handling any conditional statement (if, unless) + # handles meta_type(:condition) + # @param type [Symbol] the meta-type to match. A meta-type can be + # any method name + "?" that {AstNode} responds to. + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:105 + def meta_type(type); end + + # Matcher for handling any type of method call. Method calls can + # be expressed by many {AstNode} types depending on the syntax + # with which it is called, so YARD allows you to use this matcher + # to simplify matching a method call. + # + # @example Match the "describe" method call + # handles method_call(:describe) + # + # # The following will be matched: + # # describe(...) + # # object.describe(...) + # # describe "argument" do ... end + # @param name [#to_s] matches the method call of this name + # @return [void] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:86 + def method_call(name = T.unsafe(nil)); end + end +end + +# Matches if/unless conditions inside classes and attempts to process only +# one branch (by evaluating the condition if possible). +# +# @example A simple class conditional +# class Foo +# if 0 +# # This method is ignored +# def xyz; end +# end +# end +# +# source://yard-0.9.28/lib/yard/handlers/ruby/class_condition_handler.rb:12 +class YARD::Handlers::Ruby::ClassConditionHandler < ::YARD::Handlers::Ruby::Base + protected + + # Parses the condition part of the if/unless statement + # + # @return [true, false, nil] true if the condition can be definitely + # parsed to true, false if not, and nil if the condition cannot be + # parsed with certainty (it's dynamic) + # + # source://yard-0.9.28/lib/yard/handlers/ruby/class_condition_handler.rb:36 + def parse_condition; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_condition_handler.rb:87 + def parse_else_block; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_condition_handler.rb:83 + def parse_then_block; end +end + +# Handles class declarations +# +# source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:3 +class YARD::Handlers::Ruby::ClassHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::StructHandlerMethods + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:73 + def create_struct_superclass(superclass, superclass_def); end + + # Extract the parameters from the Struct.new AST node, returning them as a list + # of strings + # + # @param superclass [MethodCallNode] the AST node for the Struct.new call + # @return [Array<String>] the member names to generate methods for + # + # source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:67 + def extract_parameters(superclass); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:92 + def parse_struct_superclass(klass, superclass); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:98 + def parse_superclass(superclass); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/class_handler.rb:82 + def struct_superclass_name(superclass); end +end + +# Handles a class variable (@@variable) +# +# source://yard-0.9.28/lib/yard/handlers/ruby/class_variable_handler.rb:3 +class YARD::Handlers::Ruby::ClassVariableHandler < ::YARD::Handlers::Ruby::Base; end + +# Handles any lone comment statement in a Ruby file +# +# source://yard-0.9.28/lib/yard/handlers/ruby/comment_handler.rb:3 +class YARD::Handlers::Ruby::CommentHandler < ::YARD::Handlers::Ruby::Base; end + +# Handles any constant assignment +# +# source://yard-0.9.28/lib/yard/handlers/ruby/constant_handler.rb:3 +class YARD::Handlers::Ruby::ConstantHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::StructHandlerMethods + + private + + # Extract the parameters from the Struct.new AST node, returning them as a list + # of strings + # + # @param superclass [MethodCallNode] the AST node for the Struct.new call + # @return [Array<String>] the member names to generate methods for + # + # source://yard-0.9.28/lib/yard/handlers/ruby/constant_handler.rb:49 + def extract_parameters(superclass); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/constant_handler.rb:21 + def process_constant(statement); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/constant_handler.rb:33 + def process_structclass(statement); end +end + +# Handles automatic detection of dsl-style methods +# +# source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler.rb:6 +class YARD::Handlers::Ruby::DSLHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::DSLHandlerMethods +end + +# source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:5 +module YARD::Handlers::Ruby::DSLHandlerMethods + include ::YARD::CodeObjects + include ::YARD::Parser + + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:14 + def handle_comments; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:48 + def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:72 + def find_attached_macro; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:54 + def implicit_docstring?; end + + # @return [Boolean] whether caller method matches a macro or + # its alias names. + # + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:85 + def macro_name_matches(macro); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:59 + def method_name; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:68 + def method_signature; end +end + +# source://yard-0.9.28/lib/yard/handlers/ruby/dsl_handler_methods.rb:9 +YARD::Handlers::Ruby::DSLHandlerMethods::IGNORE_METHODS = T.let(T.unsafe(nil), Hash) + +# Helper methods to assist with processing decorators. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/decorator_handler_methods.rb:3 +module YARD::Handlers::Ruby::DecoratorHandlerMethods + # @overload process_decorator + # + # source://yard-0.9.28/lib/yard/handlers/ruby/decorator_handler_methods.rb:43 + def process_decorator(*nodes, &block); end + + private + + # @yield [method, node, name.to_sym] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/decorator_handler_methods.rb:78 + def process_decorator_parameter(node, opts = T.unsafe(nil), &block); end +end + +# Handles 'raise' calls inside methods +# +# source://yard-0.9.28/lib/yard/handlers/ruby/exception_handler.rb:3 +class YARD::Handlers::Ruby::ExceptionHandler < ::YARD::Handlers::Ruby::Base; end + +# Handles 'extend' call to include modules into the class scope of another +# +# @see MixinHandler +# +# source://yard-0.9.28/lib/yard/handlers/ruby/extend_handler.rb:4 +class YARD::Handlers::Ruby::ExtendHandler < ::YARD::Handlers::Ruby::MixinHandler + # source://yard-0.9.28/lib/yard/handlers/ruby/extend_handler.rb:8 + def scope; end + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/extend_handler.rb:12 + def process_mixin(mixin); end +end + +# To implement a custom handler matcher, subclass this class and implement +# {#matches?} to return whether a node matches the handler. +# +# @example A Custom Handler Matcher Extension +# # Implements a handler that checks for a specific string +# # in the node's source. +# class MyExtension < HandlesExtension +# def matches?(node) node.source.include?(name) end +# end +# +# # This handler will handle any node where the source includes 'foo' +# class MyHandler < Handlers::Ruby::Base +# handles MyExtension.new('foo') +# end +# +# source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:19 +class YARD::Handlers::Ruby::HandlesExtension + # Creates a new extension with a specific matcher value +name+ + # + # @param name [Object] the matcher value to check against {#matches?} + # @return [HandlesExtension] a new instance of HandlesExtension + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:22 + def initialize(name); end + + # Tests if the node matches the handler + # + # @param node [Parser::Ruby::AstNode] a Ruby node + # @raise [NotImplementedError] + # @return [Boolean] whether the +node+ matches the handler + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:27 + def matches?(node); end + + protected + + # @return [String] the extension matcher value + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:34 + def name; end +end + +# Handlers for old Ruby 1.8 parser +# +# source://yard-0.9.28/lib/yard/autoload.rb:93 +module YARD::Handlers::Ruby::Legacy; end + +# Handles alias and alias_method calls +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/alias_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::AliasHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles +attr_*+ statements in modules/classes +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/attribute_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::AttributeHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# This is the base handler for the legacy parser. To implement a legacy +# handler, subclass this class. +# +# @abstract See {Handlers::Base} for subclassing information. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:10 +class YARD::Handlers::Ruby::Legacy::Base < ::YARD::Handlers::Base + include ::YARD::Parser::Ruby::Legacy::RubyToken + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:44 + def call_params; end + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:53 + def caller_method; end + + # Parses a statement's block with a set of state values. If the + # statement has no block, nothing happens. A description of state + # values can be found at {Handlers::Base#push_state} + # + # @option opts + # @option opts + # @option opts + # @param opts [Hash] State options + # @see Handlers::Base#push_state #push_state + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:35 + def parse_block(opts = T.unsafe(nil)); end + + private + + # Extracts method information for macro expansion only + # + # @return [Array<String,Array<Array<String>>>] the method name followed by method + # arguments (name and optional value) + # @todo This is a duplicate implementation of {MethodHandler}. Refactor. + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:68 + def extract_method_details; end + + # The string value of a token. For example, the return value for the symbol :sym + # would be :sym. The return value for a string +"foo #{ bar}"+ would be the literal + # +"foo #{ bar}"+ without any interpolation. The return value of the identifier + # 'test' would be the same value: 'test'. Here is a list of common types and + # their return values: + # + # @example + # tokval(TokenList.new('"foo"').first) => "foo" + # tokval(TokenList.new(':foo').first) => :foo + # tokval(TokenList.new('CONSTANT').first, RubyToken::TkId) => "CONSTANT" + # tokval(TokenList.new('identifier').first, RubyToken::TkId) => "identifier" + # tokval(TokenList.new('3.25').first) => 3.25 + # tokval(TokenList.new('/xyz/i').first) => /xyz/i + # @param token [Token] The token of the class + # @param accepted_types [Array<Class<Token>>, Symbol] The allowed token types that this token can be. Defaults to [{TkVal}]. + # A list of types would be, for example, [+TkSTRING+, +TkSYMBOL+], to return + # the token's value if it is either of those types. If +TkVal+ is accepted, + # +TkNode+ is also accepted. + # + # Certain symbol keys are allowed to specify multiple types in one fell swoop. + # These symbols are: + # :string => +TkSTRING+, +TkDSTRING+, +TkDXSTRING+ and +TkXSTRING+ + # :attr => +TkSYMBOL+ and +TkSTRING+ + # :identifier => +TkIDENTIFIER, +TkFID+ and +TkGVAR+. + # :number => +TkFLOAT+, +TkINTEGER+ + # @return [Object] if the token is one of the accepted types, in its real value form. + # It should be noted that identifiers and constants are kept in String form. + # @return [nil] if the token is not any of the specified accepted types + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:112 + def tokval(token, *accepted_types); end + + # Returns a list of symbols or string values from a statement. + # The list must be a valid comma delimited list, and values + # will only be returned to the end of the list only. + # + # Example: + # attr_accessor :a, 'b', :c, :d => ['a', 'b', 'c', 'd'] + # attr_accessor 'a', UNACCEPTED_TYPE, 'c' => ['a', 'c'] + # + # The tokval list of a {Parser::Ruby::Legacy::TokenList} of the above + # code would be the {#tokval} value of :a, 'b', + # :c and :d. + # + # It should also be noted that this function stops immediately at + # any ruby keyword encountered: + # "attr_accessor :a, :b, :c if x == 5" => ['a', 'b', 'c'] + # + # @param tokenlist [TokenList] The list of tokens to process. + # @param accepted_types [Array<Class<Token>>] passed to {#tokval} + # @return [Array<String>] the list of tokvalues in the list. + # @return [Array<EMPTY>] if there are no symbols or Strings in the list + # @see #tokval + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:178 + def tokval_list(tokenlist, *accepted_types); end + + class << self + # @return [Boolean] whether or not a {Parser::Ruby::Legacy::Statement} object should be handled + # by this handler. + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/base.rb:15 + def handles?(stmt); end + end +end + +# Matches if/unless conditions inside classes and attempts to process only +# one branch (by evaluating the condition if possible). +# +# @example A simple class conditional +# class Foo +# if 0 +# # This method is ignored +# def xyz; end +# end +# end +# @since 0.5.4 +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_condition_handler.rb:4 +class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < ::YARD::Handlers::Ruby::Legacy::Base + protected + + # Parses the condition part of the if/unless statement + # + # @return [true, false, nil] true if the condition can be definitely + # parsed to true, false if not, and nil if the condition cannot be + # parsed with certainty (it's dynamic) + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_condition_handler.rb:29 + def parse_condition; end + + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_condition_handler.rb:73 + def parse_else_block; end + + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_condition_handler.rb:68 + def parse_then_block; end +end + +# Handles class declarations +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ClassHandler < ::YARD::Handlers::Ruby::Legacy::Base + include ::YARD::Handlers::Ruby::StructHandlerMethods + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:74 + def create_struct_superclass(superclass, superclass_def); end + + # Extracts the parameter list from the Struct.new declaration and returns it + # formatted as a list of member names. Expects the user will have used symbols + # to define the struct member names + # + # @param superstring [String] the string declaring the superclass + # @return [Array<String>] a list of member names + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:69 + def extract_parameters(superstring); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:95 + def parse_struct_subclass(klass, superclass_def); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:102 + def parse_superclass(superclass); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_handler.rb:83 + def struct_superclass_name(superclass); end +end + +# Handles a class variable (@@variable) +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_variable_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/class_variable_handler.rb:4 +YARD::Handlers::Ruby::Legacy::ClassVariableHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp) + +# Handles any lone comment statement in a Ruby file +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/comment_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::CommentHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles any constant assignment +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/constant_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base + include ::YARD::Handlers::Ruby::StructHandlerMethods + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/constant_handler.rb:25 + def extract_parameters(parameters); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/constant_handler.rb:20 + def process_structclass(classname, parameters); end +end + +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/constant_handler.rb:5 +YARD::Handlers::Ruby::Legacy::ConstantHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp) + +# Handles automatic detection of dsl-style methods +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/dsl_handler.rb:7 +class YARD::Handlers::Ruby::Legacy::DSLHandler < ::YARD::Handlers::Ruby::Legacy::Base + include ::YARD::Handlers::Ruby::DSLHandlerMethods +end + +# Handles 'raise' calls inside methods +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/exception_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ExceptionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles 'extend' call to include modules into the class scope of another +# +# @see MixinHandler +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/extend_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ExtendHandler < ::YARD::Handlers::Ruby::Legacy::MixinHandler + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/extend_handler.rb:7 + def scope; end + + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/extend_handler.rb:11 + def process_mixin(mixin); end +end + +# Handles a method definition +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/method_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::MethodHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles the 'include' statement to mixin a module in the instance scope +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/mixin_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::MixinHandler < ::YARD::Handlers::Ruby::Legacy::Base + private + + # @raise [YARD::Parser::UndocumentableError] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/mixin_handler.rb:26 + def process_mixin(mixin); end +end + +# Handles module_function calls to turn methods into public class methods. +# Also creates a private instance copy of the method. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/module_function_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles the declaration of a module +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/module_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::ModuleHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Sets visibility of a class method to private. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/private_class_method_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Legacy::Base + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/private_class_method_handler.rb:15 + def privatize_class_method(name); end +end + +# Sets visibility of a constant (class, module, const) +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/private_constant_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/legacy/private_constant_handler.rb:15 + def privatize_constant(name); end +end + +# Handles 'private', 'protected', and 'public' calls. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/visibility_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::VisibilityHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# Handles 'yield' calls +# +# source://yard-0.9.28/lib/yard/handlers/ruby/legacy/yield_handler.rb:3 +class YARD::Handlers::Ruby::Legacy::YieldHandler < ::YARD::Handlers::Ruby::Legacy::Base; end + +# source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:37 +class YARD::Handlers::Ruby::MethodCallWrapper < ::YARD::Handlers::Ruby::HandlesExtension + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:38 + def matches?(node); end +end + +# Handles a conditional inside a method +# +# source://yard-0.9.28/lib/yard/handlers/ruby/method_condition_handler.rb:3 +class YARD::Handlers::Ruby::MethodConditionHandler < ::YARD::Handlers::Ruby::Base; end + +# Handles a method definition +# +# source://yard-0.9.28/lib/yard/handlers/ruby/method_handler.rb:3 +class YARD::Handlers::Ruby::MethodHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Common::MethodHandler + + # source://yard-0.9.28/lib/yard/handlers/ruby/method_handler.rb:69 + def format_args; end +end + +# Handles the 'include' statement to mixin a module in the instance scope +# +# source://yard-0.9.28/lib/yard/handlers/ruby/mixin_handler.rb:3 +class YARD::Handlers::Ruby::MixinHandler < ::YARD::Handlers::Ruby::Base + protected + + # @raise [YARD::Parser::UndocumentableError] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/mixin_handler.rb:25 + def process_mixin(mixin); end + + # source://yard-0.9.28/lib/yard/handlers/ruby/mixin_handler.rb:43 + def recipient(mixin); end +end + +# Handles module_function calls to turn methods into public class methods. +# Also creates a private instance copy of the method. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/module_function_handler.rb:4 +class YARD::Handlers::Ruby::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::DecoratorHandlerMethods + + # source://yard-0.9.28/lib/yard/handlers/ruby/module_function_handler.rb:34 + def make_module_function(instance_method, namespace); end +end + +# Handles the declaration of a module +# +# source://yard-0.9.28/lib/yard/handlers/ruby/module_handler.rb:3 +class YARD::Handlers::Ruby::ModuleHandler < ::YARD::Handlers::Ruby::Base; end + +# Sets visibility of a class method to private. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/private_class_method_handler.rb:3 +class YARD::Handlers::Ruby::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::DecoratorHandlerMethods +end + +# Sets visibility of a constant (class, module, const) +# +# source://yard-0.9.28/lib/yard/handlers/ruby/private_constant_handler.rb:6 +class YARD::Handlers::Ruby::PrivateConstantHandler < ::YARD::Handlers::Ruby::Base + private + + # source://yard-0.9.28/lib/yard/handlers/ruby/private_constant_handler.rb:28 + def privatize_constant(node); end +end + +# Sets visibility of a class method to public. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/public_class_method_handler.rb:3 +class YARD::Handlers::Ruby::PublicClassMethodHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::DecoratorHandlerMethods +end + +# Helper methods to parse @attr_* tags on a class. +# +# @deprecated The use of +@attr+ tags are deprecated since 0.8.0 in favour of +# the +@!attribute+ directive. This module should not be relied on. +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:7 +module YARD::Handlers::Ruby::StructHandlerMethods + include ::YARD::CodeObjects + + # Creates the auto-generated docstring for the getter method of a struct's + # member. This is used so the generated documentation will look just like that + # of an attribute defined using attr_accessor. + # + # @param klass [ClassObject] the class whose members we're working with + # @param member [String] the name of the member we're generating documentation for + # @return [String] a docstring to be attached to the getter method for this member + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:62 + def add_reader_tags(klass, new_method, member); end + + # Creates the auto-generated docstring for the setter method of a struct's + # member. This is used so the generated documentation will look just like that + # of an attribute defined using attr_accessor. + # + # @param klass [ClassObject] the class whose members we're working with + # @param member [String] the name of the member we're generating documentation for + # @return [String] a docstring to be attached to the setter method for this member + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:77 + def add_writer_tags(klass, new_method, member); end + + # Creates the given member methods and attaches them to the given ClassObject. + # + # @param klass [ClassObject] the class to generate attributes for + # @param members [Array<String>] a list of member names + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:134 + def create_attributes(klass, members); end + + # Creates and registers a class object with the given name and superclass name. + # Returns it for further use. + # + # @param classname [String] the name of the class + # @param superclass [String] the name of the superclass + # @return [ClassObject] the class object for further processing/method attaching + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:92 + def create_class(classname, superclass); end + + # Determines whether to create an attribute method based on the class's + # tags. + # + # @param klass [ClassObject] the class whose tags we're searching + # @param member [String] the name of the struct member we need + # @param type [Symbol] (:read) reader method, or writer method? + # @return [Boolean] should the attribute be created? + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:38 + def create_member_method?(klass, member, type = T.unsafe(nil)); end + + # Creates the getter (reader) method and attaches it to the class as an attribute. + # Also sets up the docstring to prettify the documentation output. + # + # @param klass [ClassObject] the class to attach the method to + # @param member [String] the name of the member we're generating a method for + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:121 + def create_reader(klass, member); end + + # Creates the setter (writer) method and attaches it to the class as an attribute. + # Also sets up the docstring to prettify the documentation output. + # + # @param klass [ClassObject] the class to attach the method to + # @param member [String] the name of the member we're generating a method for + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:104 + def create_writer(klass, member); end + + # Extracts the user's defined @member tag for a given class and its member. Returns + # nil if the user did not define a @member tag for this struct entry. + # + # @param klass [ClassObject] the class whose tags we're searching + # @param member [String] the name of the struct member we need + # @param type [Symbol] reader method, or writer method? + # @return [Tags::Tag, nil] the tag matching the request, or nil if not found + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:17 + def member_tag_for_member(klass, member, type = T.unsafe(nil)); end + + # Retrieves all members defined in @attr* tags + # + # @param klass [ClassObject] the class with the attributes + # @return [Array<String>] the list of members defined as attributes on the class + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:26 + def members_from_tags(klass); end + + # Gets the return type for the member in a nicely formatted string. Used + # to be injected into auto-generated docstrings. + # + # @param member_tag [Tags::Tag] the tag object to check for types + # @return [String] the user-declared type of the struct member, or [Object] if + # the user did not define a type for this member. + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/handlers/ruby/struct_handler_methods.rb:51 + def return_type_from_tag(member_tag); end +end + +# source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:53 +class YARD::Handlers::Ruby::TestNodeWrapper < ::YARD::Handlers::Ruby::HandlesExtension + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/handlers/ruby/base.rb:54 + def matches?(node); end +end + +# Handles 'private', 'protected', and 'public' calls. +# +# source://yard-0.9.28/lib/yard/handlers/ruby/visibility_handler.rb:3 +class YARD::Handlers::Ruby::VisibilityHandler < ::YARD::Handlers::Ruby::Base + include ::YARD::Handlers::Ruby::DecoratorHandlerMethods +end + +# Handles 'yield' calls +# +# source://yard-0.9.28/lib/yard/handlers/ruby/yield_handler.rb:3 +class YARD::Handlers::Ruby::YieldHandler < ::YARD::Handlers::Ruby::Base; end + +# Namespace for internationalization (i18n) +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/autoload.rb:151 +module YARD::I18n; end + +# +Locale+ is a unit of translation. It has {#name} and a set of +# messages. +# +# @since 0.8.2 +# +# source://yard-0.9.28/lib/yard/i18n/locale.rb:8 +class YARD::I18n::Locale + # Creates a locale for +name+ locale. + # + # @param name [String] the locale name. + # @return [Locale] a new instance of Locale + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:34 + def initialize(name); end + + # Loads translation messages from +locale_directory+/{#name}.po. + # + # @param locale_directory [String] the directory path that has + # {#name}.po. + # @return [Boolean] +true+ if PO file exists, +false+ otherwise. + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:44 + def load(locale_directory); end + + # @return [String] the name of the locale. It used IETF language + # tag format +[language[_territory][.codeset][@modifier]]+. + # @see http://tools.ietf.org/rfc/bcp/bcp47.txt BCP 47 - Tags for Identifying Languages + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:29 + def name; end + + # @param message [String] the translation target message. + # @return [String] translated message. If tarnslation isn't + # registered, the +message+ is returned. + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:62 + def translate(message); end + + class << self + # @return [String, nil] the default locale name. + # @since 0.8.4 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:15 + def default; end + + # @return [String, nil] the default locale name. + # @since 0.8.4 + # + # source://yard-0.9.28/lib/yard/i18n/locale.rb:20 + def default=(locale); end + end +end + +# +Message+ is a translation target message. It has message ID as +# {#id} and some properties {#locations} and {#comments}. +# +# @since 0.8.1 +# +# source://yard-0.9.28/lib/yard/i18n/message.rb:10 +class YARD::I18n::Message + # Creates a trasnlate target message for message ID +id+. + # + # @param id [String] the message ID of the translate target message. + # @return [Message] a new instance of Message + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:24 + def initialize(id); end + + # @param other [Message] the +Message+ to be compared. + # @return [Boolean] checks whether this message is equal to another. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:49 + def ==(other); end + + # Adds a comment for the message. + # + # @param comment [String] the comment for the message to be added. + # @return [void] + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:43 + def add_comment(comment); end + + # Adds location information for the message. + # + # @param path [String] the path where the message appears. + # @param line [Integer] the line number where the message appears. + # @return [void] + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:35 + def add_location(path, line); end + + # @return [Set] the set of comments for the messages. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:19 + def comments; end + + # @return [String] the message ID of the trnslation target message. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:12 + def id; end + + # path and line number where the message is appeared. + # + # @return [Set] the set of locations. Location is an array of + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/message.rb:16 + def locations; end +end + +# Acts as a container for {Message} objects. +# +# @since 0.8.1 +# +# source://yard-0.9.28/lib/yard/i18n/messages.rb:7 +class YARD::I18n::Messages + include ::Enumerable + + # Creates a new container. + # + # @return [Messages] a new instance of Messages + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:11 + def initialize; end + + # Checks if this messages list is equal to another messages list. + # + # @param other [Messages] the container to compare. + # @return [Boolean] whether +self+ and +other+ is equivalence or not. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:45 + def ==(other); end + + # @param id [String] the message ID to perform a lookup on. + # @return [Message, nil] a registered message for the given +id+, + # or nil if no message for the ID is found. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:27 + def [](id); end + + # Enumerates each {Message} in the container. + # + # @return [void] + # @since 0.8.1 + # @yieldparam message [Message] the next message object in + # the enumeration. + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:20 + def each(&block); end + + # Registers a {Message}, the mssage ID of which is +id+. If + # corresponding +Message+ is already registered, the previously + # registered object is returned. + # + # @param id [String] the ID of the message to be registered. + # @return [Message] the registered +Message+. + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:37 + def register(id); end + + protected + + # @return [Hash{String=>Message}] the set of message objects + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/messages.rb:53 + def messages; end +end + +# The +PotGenerator+ generates POT format string from +# {CodeObjects::Base} and {CodeObjects::ExtraFileObject}. +# +# == POT and PO +# +# POT is an acronym for "Portable Object Template". POT is a +# template file to create PO file. The extension for POT is +# ".pot". PO file is an acronym for "Portable Object". PO file has +# many parts of message ID (msgid) that is translation target +# message and message string (msgstr) that is translated message +# of message ID. If you want to translate "Hello" in English into +# "Bonjour" in French, "Hello" is the msgid ID and "Bonjour" is +# msgstr. The extension for PO is ".po". +# +# == How to extract msgids +# +# The +PotGenerator+ has two parse methods: +# +# * {#parse_objects} for {CodeObjects::Base} +# * {#parse_files} for {CodeObjects::ExtraFileObject} +# +# {#parse_objects} extracts msgids from docstring and tags of +# {CodeObjects::Base} objects. The docstring of +# {CodeObjects::Base} object is parsed and a paragraph is +# extracted as a msgid. Tag name and tag text are extracted as +# msgids from a tag. +# +# {#parse_files} extracts msgids from +# {CodeObjects::ExtraFileObject} objects. The file content of +# {CodeObjects::ExtraFileObject} object is parsed and a paragraph +# is extracted as a msgid. +# +# == Usage +# +# To create a .pot file by +PotGenerator+, instantiate a +# +PotGenerator+ with a relative working directory path from a +# directory path that has created .pot file, parse +# {CodeObjects::Base} objects and {CodeObjects::ExtraFileObject} +# objects, generate a POT and write the generated POT to a .pot +# file. The relative working directory path is ".." when the +# working directory path is "." and the POT is wrote into +# "po/yard.pot". +# +# @example Generate a .pot file +# po_file_path = "po/yard.pot" +# po_file_directory_pathname = Pathname.new(po_file_path).directory) +# working_directory_pathname = Pathname.new(".") +# relative_base_path = working_directory_pathname.relative_path_from(po_file_directory_pathname).to_s +# # relative_base_path -> ".." +# generator = YARD::I18n::PotGenerator.new(relative_base_path) +# generator.parse_objects(objects) +# generator.parse_files(files) +# pot = generator.generate +# po_file_directory_pathname.mkpath +# File.open(po_file_path, "w") do |pot_file| +# pot_file.print(pot) +# end +# @see http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html GNU gettext manual about details of PO file +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:65 +class YARD::I18n::PotGenerator + # Creates a POT generator that uses +relative_base_path+ to + # generate locations for a msgid. +relative_base_path+ is + # prepended to all locations. + # + # @param relative_base_path [String] a relative working + # directory path from a directory path that has created .pot + # file. + # @return [PotGenerator] a new instance of PotGenerator + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:79 + def initialize(relative_base_path); end + + # Generates POT from +@messages+. + # + # One PO file entry is generated from a +Message+ in + # +@messages+. + # + # Locations of the +Message+ are used to generate the reference + # line that is started with "#: ". +relative_base_path+ passed + # when the generater is created is prepended to each path in location. + # + # Comments of the +Message+ are used to generate the + # translator-comment line that is started with "# ". + # + # @return [String] POT format string + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:122 + def generate; end + + # Extracted messages. + # + # @return [Messages] + # @since 0.8.1 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:70 + def messages; end + + # Parses {CodeObjects::ExtraFileObject} objects and stores + # extracted msgids into {#messages}. + # + # @param files [Array<CodeObjects::ExtraFileObject>] a list + # of {CodeObjects::ExtraFileObject} objects to be parsed. + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:103 + def parse_files(files); end + + # Parses {CodeObjects::Base} objects and stores extracted msgids + # into {#messages} + # + # @param objects [Array<CodeObjects::Base>] a list of + # {CodeObjects::Base} to be parsed. + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:91 + def parse_objects(objects); end + + private + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:160 + def current_time; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:183 + def escape_message_id(message_id); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:194 + def extract_documents(object); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:268 + def extract_paragraphs(file); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:235 + def extract_tag_documents(tag); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:242 + def extract_tag_name(tag); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:255 + def extract_tag_text(tag); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:168 + def generate_message(pot, message); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:164 + def generate_pot_creation_date_value; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:136 + def header; end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/pot_generator.rb:190 + def register_message(id); end +end + +# Provides some convenient features for translating a text. +# +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/i18n/text.rb:5 +class YARD::I18n::Text + # Creates a text object that has translation related features for + # the input text. + # + # @option options + # @param input [#each_line] a text to be translated. + # @param options [Hash] a customizable set of options + # @return [Text] a new instance of Text + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:12 + def initialize(input, options = T.unsafe(nil)); end + + # Extracts translation target messages from +@input+. + # + # @return [void] + # @since 0.8.0 + # @yield [:attribute, name, value, line_no] the block that + # receives extracted an attribute in header. It may called many + # times. + # @yield [:paragraph, text, start_line_no] the block that + # receives extracted a paragraph in body. Paragraph is a text + # block separated by one or more empty lines. Empty line is a + # line that contains only zero or more whitespaces. It may + # called many times. + # @yieldparam text [String] the text of extracted paragraph. + # @yieldparam start_line_no [Integer] the start line number of + # extracted paragraph. + # @yieldparam name [String] the name of extracted attribute. + # @yieldparam value [String] the value of extracted attribute. + # @yieldparam line_no [Integer] the defined line number of extracted + # attribute. + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:35 + def extract_messages; end + + # Translates into +locale+. + # + # @param locale [Locale] the translation target locale. + # @return [String] translated text. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:52 + def translate(locale); end + + private + + # @since 0.8.0 + # @yield [part] + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:134 + def emit_attribute_event(match_data, line_no); end + + # @since 0.8.0 + # @yield [part] + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:147 + def emit_empty_line_event(line, line_no); end + + # @since 0.8.0 + # @yield [part] + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:125 + def emit_markup_event(line, line_no); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:156 + def emit_paragraph_event(paragraph, paragraph_start_line, line_no, &block); end + + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/i18n/text.rb:76 + def parse(&block); end +end + +# Handles console logging for info, warnings and errors. +# Uses the stdlib Logger class in Ruby for all the backend logic. +# +# source://yard-0.9.28/lib/yard/logging.rb:12 +class YARD::Logger < ::Logger + # Creates a new logger + # + # @return [Logger] a new instance of Logger + # + # source://yard-0.9.28/lib/yard/logging.rb:43 + def initialize(pipe, *args); end + + # Displays an unformatted line to the logger output stream. + # + # @param msg [String] the message to display + # @return [void] + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:143 + def <<(msg = T.unsafe(nil)); end + + # Prints the backtrace +exc+ to the logger as error data. + # + # @param exc [Array<String>] the backtrace list + # @param level_meth [Symbol] the level to log backtrace at + # @return [void] + # + # source://yard-0.9.28/lib/yard/logging.rb:154 + def backtrace(exc, level_meth = T.unsafe(nil)); end + + # Captures the duration of a block of code for benchmark analysis. Also + # calls {#progress} on the message to display it to the user. + # + # @param msg [String] the message to display + # @param nontty_log [Symbol, nil] the level to log as if the output + # stream is not a TTY. Use +nil+ for no alternate logging. + # @return [void] + # @todo Implement capture storage for reporting of benchmarks + # @yield a block of arbitrary code to benchmark + # + # source://yard-0.9.28/lib/yard/logging.rb:80 + def capture(msg, nontty_log = T.unsafe(nil)); end + + # Clears the progress indicator in the TTY display. + # + # @return [void] + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:121 + def clear_progress; end + + # Changes the debug level to DEBUG if $DEBUG is set + # and writes a debugging message. + # + # source://yard-0.9.28/lib/yard/logging.rb:59 + def debug(*args); end + + # Sets the logger level for the duration of the block + # + # @example + # log.enter_level(Logger::ERROR) do + # YARD.parse_string "def x; end" + # end + # @param new_level [Fixnum] the logger level for the duration of the block. + # values can be found in Ruby's Logger class. + # @yield the block with the logger temporarily set to +new_level+ + # + # source://yard-0.9.28/lib/yard/logging.rb:179 + def enter_level(new_level = T.unsafe(nil)); end + + # @return [IO] the IO object being logged to + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:17 + def io; end + + # source://yard-0.9.28/lib/yard/logging.rb:18 + def io=(pipe); end + + # Displays an unformatted line to the logger output stream. + # + # @param msg [String] the message to display + # @return [void] + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:143 + def print(msg = T.unsafe(nil)); end + + # Displays a progress indicator for a given message. This progress report + # is only displayed on TTY displays, otherwise the message is passed to + # the +nontty_log+ level. + # + # @param msg [String] the message to log + # @param nontty_log [Symbol, nil] the level to log as if the output + # stream is not a TTY. Use +nil+ for no alternate logging. + # @return [void] + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:96 + def progress(msg, nontty_log = T.unsafe(nil)); end + + # Displays an unformatted line to the logger output stream, adding + # a newline. + # + # @param msg [String] the message to display + # @return [void] + # @since 0.8.2 + # + # source://yard-0.9.28/lib/yard/logging.rb:132 + def puts(msg = T.unsafe(nil)); end + + # @return [Boolean] whether backtraces should be shown (by default + # this is on). + # + # source://yard-0.9.28/lib/yard/logging.rb:22 + def show_backtraces; end + + # Sets the attribute show_backtraces + # + # @param value the value to set the attribute show_backtraces to. + # + # source://yard-0.9.28/lib/yard/logging.rb:23 + def show_backtraces=(_arg0); end + + # @return [Boolean] whether progress indicators should be shown when + # logging CLIs (by default this is off). + # + # source://yard-0.9.28/lib/yard/logging.rb:27 + def show_progress; end + + # Sets the attribute show_progress + # + # @param value the value to set the attribute show_progress to. + # + # source://yard-0.9.28/lib/yard/logging.rb:34 + def show_progress=(_arg0); end + + # Remembers when a warning occurs and writes a warning message. + # + # source://yard-0.9.28/lib/yard/logging.rb:65 + def warn(*args); end + + # Warns that the Ruby environment does not support continuations. Applies + # to JRuby, Rubinius and MacRuby. This warning will only display once + # per Ruby process. + # + # @deprecated Continuations are no longer needed by YARD 0.8.0+. + # @return [void] + # + # source://yard-0.9.28/lib/yard/logging.rb:167 + def warn_no_continuations; end + + # Returns the value of attribute warned. + # + # source://yard-0.9.28/lib/yard/logging.rb:69 + def warned; end + + # Sets the attribute warned + # + # @param value the value to set the attribute warned to. + # + # source://yard-0.9.28/lib/yard/logging.rb:69 + def warned=(_arg0); end + + private + + # Override this internal Logger method to clear line + # + # source://yard-0.9.28/lib/yard/logging.rb:190 + def add(*args); end + + # source://yard-0.9.28/lib/yard/logging.rb:195 + def clear_line; end + + # Log format (from Logger implementation). Used by Logger internally + # + # source://yard-0.9.28/lib/yard/logging.rb:201 + def format_log(sev, _time, _prog, msg); end + + # source://RUBY_ROOT/logger.rb:484 + def print_no_newline(msg); end + + class << self + # The logger instance + # + # @return [Logger] the logger instance + # + # source://yard-0.9.28/lib/yard/logging.rb:38 + def instance(pipe = T.unsafe(nil)); end + end +end + +# The list of characters displayed beside the progress bar to indicate +# "movement". +# +# @since 0.8.2 +# +# source://yard-0.9.28/lib/yard/logging.rb:13 +YARD::Logger::PROGRESS_INDICATORS = T.let(T.unsafe(nil), Array) + +# Generalized options class for passing around large amounts of options between objects. +# +# The options class exists for better visibility and documentability of options being +# passed through to other objects. Because YARD has parser and template architectures +# that are heavily reliant on options, it is necessary to make these option keys easily +# visible and understood by developers. Since the options class is more than just a +# basic Hash, the subclass can provide aliasing and convenience methods to simplify +# option property access, and, if needed, support backward-compatibility for deprecated +# key names. +# +# == Hash and OpenStruct-like Access +# +# Although the options class allows for Hash-like access (<tt>opts[:key]</tt>), the recommended +# mechanism for accessing an option key will be via standard method calls on attributes +# +# The options class can also act as an open ended key value storage structure (like a +# Hash or OpenStruct), and allows for setting and getting of unregistered option keys. +# This methodology is not recommended, however, and is only supported for backward +# compatibility inside YARD. Whenever possible, developers should define all keys used +# by an options class. +# +# == Declaring Default Values +# +# Note that the options class can contain default value definitions for certain options, +# but to initialize these defaults, {#reset_defaults} must be called manually after +# initialization; the options object is always created empty until defaults are applied. +# +# @abstract Subclasses should define (and document) custom attributes that are expected +# to be made available as option keys. +# @example Defining an Options class with custom option keys +# class TemplateOptions < YARD::Options +# # @return [Symbol] the output format to generate templates in +# attr_accessor :format +# +# # @return [Symbol] the template to use when generating output +# attr_accessor :template +# end +# @example Initializing default option values +# class TemplateOptions < YARD::Options +# def reset_defaults +# super +# self.format = :html +# self.template = :default +# self.highlight = true +# # ... +# end +# end +# @example Using +default_attr+ to create default attributes +# class TemplateOptions < YARD::Options +# default_attr :format, :html +# default_attr :template, :default +# default_attr :highlight, true +# end +# @example Deprecating an option while still supporting it +# class TemplateOptions < YARD::Options +# # @return [Boolean] if syntax highlighting should be performed on code blocks. +# # Defaults to true. +# attr_accessor :highlight +# +# # @deprecated Use {#highlight} instead. +# # @return [Boolean] if no syntax highlighting should be performs on code blocks. +# # Defaults to false. +# attr_accessor :no_highlight +# def no_highlight=(value) @highlight = !value end +# def no_highlight; !highlight end +# end +# +# source://yard-0.9.28/lib/yard/options.rb:69 +class YARD::Options + # @return [Boolean] whether another Options object equals the + # keys and values of this options object + # + # source://yard-0.9.28/lib/yard/options.rb:157 + def ==(other); end + + # Delegates calls with Hash syntax to actual method with key name + # + # @example Calling on an option key with Hash syntax + # options[:format] # equivalent to: options.format + # @param key [Symbol, String] the option name to access + # @return the value of the option named +key+ + # + # source://yard-0.9.28/lib/yard/options.rb:91 + def [](key); end + + # Delegates setter calls with Hash syntax to the attribute setter with the key name + # + # @example Setting an option with Hash syntax + # options[:format] = :html # equivalent to: options.format = :html + # @param key [Symbol, String] the optin to set + # @param value [Object] the value to set for the option + # @return [Object] the value being set + # + # source://yard-0.9.28/lib/yard/options.rb:100 + def []=(key, value); end + + # Deletes an option value for +key+ + # + # @param key [Symbol, String] the key to delete a value for + # @return [Object] the value that was deleted + # + # source://yard-0.9.28/lib/yard/options.rb:207 + def delete(key); end + + # Yields over every option key and value + # + # @return [void] + # @yield [key, value] every option key and value + # @yieldparam key [Symbol] the option key + # @yieldparam value [Object] the option value + # + # source://yard-0.9.28/lib/yard/options.rb:143 + def each; end + + # Inspects the object + # + # source://yard-0.9.28/lib/yard/options.rb:151 + def inspect; end + + # Creates a new options object and sets options hash or object value + # onto that object. + # + # @param opts [Options, Hash] + # @return [Options] the newly created options object + # @see #update + # + # source://yard-0.9.28/lib/yard/options.rb:123 + def merge(opts); end + + # Handles setting and accessing of unregistered keys similar + # to an OpenStruct object. + # + # @note It is not recommended to set and access unregistered keys on + # an Options object. Instead, register the attribute before using it. + # + # source://yard-0.9.28/lib/yard/options.rb:170 + def method_missing(meth, *args, &block); end + + # Resets all values to their defaults. + # + # @abstract Subclasses should override this method to perform custom + # value initialization if not using {default_attr}. Be sure to call + # +super+ so that default initialization can take place. + # @return [void] + # + # source://yard-0.9.28/lib/yard/options.rb:188 + def reset_defaults; end + + # @return [Hash] Converts options object to an options hash. All keys + # will be symbolized. + # + # source://yard-0.9.28/lib/yard/options.rb:129 + def to_hash; end + + # Updates values from an options hash or options object on this object. + # All keys passed should be key names defined by attributes on the class. + # + # @example Updating a set of options on an Options object + # opts.update(:template => :guide, :type => :fulldoc) + # @param opts [Hash, Options] + # @return [self] + # + # source://yard-0.9.28/lib/yard/options.rb:109 + def update(opts); end + + class << self + # Defines an attribute named +key+ and sets a default value for it + # + # @example Defining a default option key + # default_attr :name, 'Default Name' + # default_attr :time, lambda { Time.now } + # @param key [Symbol] the option key name + # @param default [Object, Proc] the default object value. If the default + # value is a proc, it is executed upon initialization. + # + # source://yard-0.9.28/lib/yard/options.rb:80 + def default_attr(key, default); end + end +end + +# The parser namespace holds all parsing engines used by YARD. +# Currently only Ruby and C (Ruby) parsers are implemented. +# +# source://yard-0.9.28/lib/yard/autoload.rb:161 +module YARD::Parser; end + +# Represents the abstract base parser class that parses source code in +# a specific way. A parser should implement {#parse}, {#tokenize} and +# {#enumerator}. +# +# == Registering a Custom Parser +# To register a parser, see {SourceParser.register_parser_type} +# +# @abstract +# @see #parse +# @see #tokenize +# @see #enumerator +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/base.rb:16 +class YARD::Parser::Base + # This default constructor does nothing. The subclass is responsible for + # storing the source contents and filename if they are required. + # + # @param source [String] the source contents + # @param filename [String] the name of the file if from disk + # @raise [NotImplementedError] + # @return [Base] a new instance of Base + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/base.rb:26 + def initialize(source, filename); end + + # This method should be implemented to return a list of semantic tokens + # representing the source code to be post-processed. Otherwise the method + # should return nil. + # + # @abstract + # @return [Array] a list of semantic tokens representing the source code + # to be post-processed + # @return [nil] if no post-processing should be done + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/base.rb:52 + def enumerator; end + + # This method should be implemented to parse the source and return itself. + # + # @abstract + # @raise [NotImplementedError] + # @return [Base] this method should return itself + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/base.rb:33 + def parse; end + + # This method should be implemented to tokenize given source + # + # @abstract + # @raise [NotImplementedError] + # @return [Array] a list/tree of lexical tokens + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/base.rb:40 + def tokenize; end + + class << self + # Convenience method to create a new parser and {#parse} + # + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/base.rb:18 + def parse(source, filename = T.unsafe(nil)); end + end +end + +# CRuby Parsing components +# +# source://yard-0.9.28/lib/yard/autoload.rb:162 +module YARD::Parser::C; end + +# source://yard-0.9.28/lib/yard/parser/c/statement.rb:41 +class YARD::Parser::C::BodyStatement < ::YARD::Parser::C::Statement + # Returns the value of attribute comments. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:42 + def comments; end + + # Sets the attribute comments + # + # @param value the value to set the attribute comments to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:42 + def comments=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:5 +class YARD::Parser::C::CParser < ::YARD::Parser::Base + # @return [CParser] a new instance of CParser + # + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:6 + def initialize(source, file = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:24 + def enumerator; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:19 + def parse; end + + # @raise [NotImplementedError] + # + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:28 + def tokenize; end + + private + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:213 + def advance(num = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:216 + def advance_loop; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:195 + def attach_comment(statement); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:214 + def back(num = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:225 + def char(num = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:96 + def consume_body_statements; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:136 + def consume_comment(add_comment = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:59 + def consume_directive; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:47 + def consume_quote(type = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:73 + def consume_toplevel_statement; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:169 + def consume_until(end_char, bracket_level = T.unsafe(nil), brace_level = T.unsafe(nil), add_comment = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:132 + def consume_whitespace; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:227 + def nextchar(num = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:220 + def nextline; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:34 + def parse_toplevel; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:226 + def prevchar(num = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:118 + def strip_non_statement_data; end + + # source://yard-0.9.28/lib/yard/parser/c/c_parser.rb:229 + def struct; end +end + +# source://yard-0.9.28/lib/yard/parser/c/statement.rb:51 +class YARD::Parser::C::Comment < ::YARD::Parser::C::Statement + include ::YARD::Parser::C::CommentParser + + # @return [Comment] a new instance of Comment + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:58 + def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:62 + def comments; end + + # Returns the value of attribute overrides. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:55 + def overrides; end + + # Sets the attribute overrides + # + # @param value the value to set the attribute overrides to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:55 + def overrides=(_arg0); end + + # Returns the value of attribute statement. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:56 + def statement; end + + # Sets the attribute statement + # + # @param value the value to set the attribute statement to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:56 + def statement=(_arg0); end + + # Returns the value of attribute type. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:54 + def type; end + + # Sets the attribute type + # + # @param value the value to set the attribute type to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:54 + def type=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:5 +module YARD::Parser::C::CommentParser + protected + + # source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:8 + def parse_comments(comments); end + + private + + # source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:42 + def parse_callseq(comments); end + + # source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:30 + def parse_overrides(comments); end + + # source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:87 + def parse_types(types); end + + # source://yard-0.9.28/lib/yard/parser/c/comment_parser.rb:126 + def remove_private_comments(comment); end +end + +# source://yard-0.9.28/lib/yard/parser/c/statement.rb:5 +class YARD::Parser::C::Statement + # @return [Statement] a new instance of Statement + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:16 + def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end + + # Returns the value of attribute comments_hash_flag. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:14 + def comments_hash_flag; end + + # Sets the attribute comments_hash_flag + # + # @param value the value to set the attribute comments_hash_flag to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:14 + def comments_hash_flag=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:26 + def comments_range; end + + # Returns the value of attribute file. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:8 + def file; end + + # Sets the attribute file + # + # @param value the value to set the attribute file to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:8 + def file=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:30 + def first_line; end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:12 + def group; end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:12 + def group=(_arg0); end + + # Returns the value of attribute line. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:7 + def line; end + + # Sets the attribute line + # + # @param value the value to set the attribute line to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:7 + def line=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:22 + def line_range; end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:36 + def show; end + + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:30 + def signature; end + + # Returns the value of attribute source. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:6 + def source; end + + # Sets the attribute source + # + # @param value the value to set the attribute source to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:6 + def source=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/parser/c/statement.rb:45 +class YARD::Parser::C::ToplevelStatement < ::YARD::Parser::C::Statement + # Returns the value of attribute block. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:46 + def block; end + + # Sets the attribute block + # + # @param value the value to set the attribute block to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:46 + def block=(_arg0); end + + # Returns the value of attribute comments. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:48 + def comments; end + + # Sets the attribute comments + # + # @param value the value to set the attribute comments to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:48 + def comments=(_arg0); end + + # Returns the value of attribute declaration. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:47 + def declaration; end + + # Sets the attribute declaration + # + # @param value the value to set the attribute declaration to. + # + # source://yard-0.9.28/lib/yard/parser/c/statement.rb:47 + def declaration=(_arg0); end +end + +# Responsible for parsing a list of files in order. The +# {#parse} method of this class can be called from the +# {SourceParser#globals} globals state list to re-enter +# parsing for the remainder of files in the list recursively. +# +# @see Processor#parse_remaining_files +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:21 +class YARD::Parser::OrderedParser + # Creates a new OrderedParser with the global state and a list + # of files to parse. + # + # @note OrderedParser sets itself as the +ordered_parser+ key on + # global_state for later use in {Handlers::Processor}. + # @param global_state [OpenStruct] a structure containing all global + # state during parsing + # @param files [Array<String>] the list of files to parse + # @return [OrderedParser] a new instance of OrderedParser + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:33 + def initialize(global_state, files); end + + # @return [Array<String>] the list of remaining files to parse + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:23 + def files; end + + # @return [Array<String>] the list of remaining files to parse + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:23 + def files=(_arg0); end + + # Parses the remainder of the {#files} list. + # + # @see Processor#parse_remaining_files + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:42 + def parse; end +end + +# Raised when the parser sees a Ruby syntax error +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:13 +class YARD::Parser::ParserSyntaxError < ::YARD::Parser::UndocumentableError; end + +# Ruby parsing components. +# +# source://yard-0.9.28/lib/yard/autoload.rb:171 +module YARD::Parser::Ruby + # Builds and s-expression by creating {AstNode} objects with + # the type provided by the first argument. + # + # @example An implicit list of keywords + # ast = s(s(:kw, "if"), s(:kw, "else")) + # ast.type # => :list + # @example A method call + # s(:command, s(:var_ref, "mymethod")) + # @overload s + # @overload s + # @see AstNode#initialize + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:25 + def s(*args); end +end + +# An AST node is characterized by a type and a list of children. It +# is most easily represented by the s-expression {#s} such as: +# # AST for "if true; 5 end": +# s(s(:if, s(:var_ref, s(:kw, "true")), s(s(:int, "5")), nil)) +# +# The node type is not considered part of the list, only its children. +# So +ast[0]+ does not refer to the type, but rather the first child +# (or object). Items that are not +AstNode+ objects can be part of the +# list, like Strings or Symbols representing names. To return only +# the AstNode children of the node, use {#children}. +# +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:41 +class YARD::Parser::Ruby::AstNode < ::Array + # Creates a new AST node + # + # @option opts + # @option opts + # @option opts + # @option opts + # @option opts + # @param type [Symbol] the type of node being created + # @param arr [Array<AstNode>] the child nodes + # @param opts [Hash] any extra line options + # @return [AstNode] a new instance of AstNode + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:153 + def initialize(type, arr, opts = T.unsafe(nil)); end + + # @private + # @return [Boolean] whether the node is equal to another by checking + # the list and type + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:167 + def ==(other); end + + # @return [Boolean] whether the node has a block + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:261 + def block?; end + + # @return [Boolean] whether the node is a method call + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:241 + def call?; end + + # @return [Array<AstNode>] the {AstNode} children inside the node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:199 + def children; end + + # Returns the value of attribute docstring. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def comments; end + + # Returns the value of attribute docstring_hash_flag. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:42 + def comments_hash_flag; end + + # Returns the value of attribute docstring_range. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def comments_range; end + + # @return [Boolean] whether the node is a if/elsif/else condition + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:251 + def condition?; end + + # @return [Boolean] whether the node is a method definition + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:246 + def def?; end + + # Returns the value of attribute docstring. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def docstring; end + + # Sets the attribute docstring + # + # @param value the value to set the attribute docstring to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def docstring=(_arg0); end + + # Returns the value of attribute docstring_hash_flag. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:42 + def docstring_hash_flag; end + + # Sets the attribute docstring_hash_flag + # + # @param value the value to set the attribute docstring_hash_flag to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:42 + def docstring_hash_flag=(_arg0); end + + # Returns the value of attribute docstring_range. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def docstring_range; end + + # Sets the attribute docstring_range + # + # @param value the value to set the attribute docstring_range to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def docstring_range=(_arg0); end + + # @return [String] the filename the node was parsed from + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:76 + def file; end + + # Sets the attribute file + # + # @param value the value to set the attribute file to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:49 + def file=(_arg0); end + + # @return [String] the first line of source represented by the node. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:278 + def first_line; end + + # @return [String] the full source that the node was parsed from + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:82 + def full_source; end + + # Sets the attribute full_source + # + # @param value the value to set the attribute full_source to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:49 + def full_source=(_arg0); end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:47 + def group; end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:47 + def group=(_arg0); end + + # @return [Boolean] whether the node has a {#line_range} set + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:268 + def has_line?; end + + # @return [String] inspects the object + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:323 + def inspect; end + + # Searches through the node and all descendants and returns the + # first node with a type matching any of +node_types+, otherwise + # returns the original node (self). + # + # @example Returns the first method definition in a block of code + # ast = YARD.parse_string("if true; def x; end end").ast + # ast.jump(:def) + # # => s(:def, s(:ident, "x"), s(:params, nil, nil, nil, nil, + # # nil), s(s(:void_stmt, ))) + # @example Returns first 'def' or 'class' statement + # ast = YARD.parse_string("class X; def y; end end") + # ast.jump(:def, :class).first + # # => + # @example If the node types are not present in the AST + # ast = YARD.parse("def x; end") + # ast.jump(:def) + # @param node_types [Array<Symbol>] a set of node types to match + # @return [AstNode] the matching node, if one was found + # @return [self] if no node was found + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:193 + def jump(*node_types); end + + # @return [Boolean] whether the node is a keyword + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:236 + def kw?; end + + # @return [Fixnum] the starting line number of the node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:273 + def line; end + + # @return [Range] the line range in {#full_source} represented + # by the node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:70 + def line_range; end + + # Sets the attribute line_range + # + # @param value the value to set the attribute line_range to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:49 + def line_range=(_arg0); end + + # @return [Boolean] whether the node is a literal value + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:231 + def literal?; end + + # @return [Boolean] whether the node is a loop + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:256 + def loop?; end + + # @return [AstNode, nil] the node's parent or nil if it is a root node. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:59 + def parent; end + + # @return [AstNode, nil] the node's parent or nil if it is a root node. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:59 + def parent=(_arg0); end + + # @return [nil] pretty prints the node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:290 + def pretty_print(q); end + + # @return [Boolean] whether the node is a reference (variable, + # constant name) + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:226 + def ref?; end + + # @return [String] the first line of source the node represents + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:285 + def show; end + + # @return [String] the parse of {#full_source} that the node represents + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:89 + def source; end + + # Sets the attribute source + # + # @param value the value to set the attribute source to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def source=(_arg0); end + + # @return [Range] the character range in {#full_source} represented + # by the node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:63 + def source_range; end + + # Sets the attribute source_range + # + # @param value the value to set the attribute source_range to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:49 + def source_range=(_arg0); end + + # Returns the value of attribute source. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:43 + def to_s; end + + # @return [Boolean] whether the node is a token + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:220 + def token?; end + + # Traverses the object and yields each node (including descendants) in order. + # + # @return [void] + # @yield each descendant node in order + # @yieldparam self, [AstNode] or a child/descendant node + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:208 + def traverse; end + + # @return [Symbol] the node's unique symbolic type + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:56 + def type; end + + # @return [Symbol] the node's unique symbolic type + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:56 + def type=(_arg0); end + + # Resets node state in tree + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:331 + def unfreeze; end + + private + + # Resets line information + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:341 + def reset_line_info; end + + class << self + # Finds the node subclass that should be instantiated for a specific + # node type + # + # @param type [Symbol] the node type to find a subclass for + # @return [Class] a subclass of AstNode to instantiate the node with. + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:111 + def node_class_for(type); end + end +end + +# List of all known keywords +# +# @return [Hash] +# +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:96 +YARD::Parser::Ruby::AstNode::KEYWORDS = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:530 +class YARD::Parser::Ruby::ClassNode < ::YARD::Parser::Ruby::KeywordNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:533 + def block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:531 + def class_name; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:532 + def superclass; end +end + +# Represents a lone comment block in source +# +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:548 +class YARD::Parser::Ruby::CommentNode < ::YARD::Parser::Ruby::AstNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:549 + def comments; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:549 + def docstring; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:550 + def docstring=(value); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:554 + def first_line; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:553 + def source; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:515 +class YARD::Parser::Ruby::ConditionalNode < ::YARD::Parser::Ruby::KeywordNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:517 + def condition; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:516 + def condition?; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:520 + def else_block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:518 + def then_block; end + + private + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:527 + def cmod?; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:376 +class YARD::Parser::Ruby::KeywordNode < ::YARD::Parser::Ruby::AstNode + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:377 + def kw?; end +end + +# Handles Ruby parsing in Ruby 1.8. +# +# source://yard-0.9.28/lib/yard/autoload.rb:172 +module YARD::Parser::Ruby::Legacy; end + +# Lexical analyzer for Ruby source +# +# @private +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:314 +class YARD::Parser::Ruby::Legacy::RubyLex + include ::YARD::Parser::Ruby::Legacy::RubyToken + include ::IRB + + # @return [RubyLex] a new instance of RubyLex + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:437 + def initialize(content); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:472 + def char_no; end + + # Returns the value of attribute continue. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:430 + def continue; end + + # Returns the value of attribute exception_on_syntax_error. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:463 + def exception_on_syntax_error; end + + # Sets the attribute exception_on_syntax_error + # + # @param value the value to set the attribute exception_on_syntax_error to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:463 + def exception_on_syntax_error=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:476 + def get_read; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:480 + def getc; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:484 + def getc_of_rests; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:488 + def gets; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1257 + def identify_comment; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:945 + def identify_gvar; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1062 + def identify_here_document; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:980 + def identify_identifier; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1130 + def identify_number(start); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1111 + def identify_quotation(initial_char); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1192 + def identify_string(ltype, quoted = T.unsafe(nil), opener = T.unsafe(nil), initial_char = T.unsafe(nil)); end + + # Returns the value of attribute indent. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:465 + def indent; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:510 + def lex; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:586 + def lex_init; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:759 + def lex_int2; end + + # Returns the value of attribute lex_state. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:431 + def lex_state; end + + # io functions + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:468 + def line_no; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:506 + def peek(i = T.unsafe(nil)); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:502 + def peek_equal?(str); end + + # Returns the value of attribute read_auto_clean_up. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:462 + def read_auto_clean_up; end + + # Sets the attribute read_auto_clean_up + # + # @param value the value to set the attribute read_auto_clean_up to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:462 + def read_auto_clean_up=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1280 + def read_escape; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:1242 + def skip_inner_expression; end + + # Returns the value of attribute skip_space. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:461 + def skip_space; end + + # Sets the attribute skip_space + # + # @param value the value to set the attribute skip_space to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:461 + def skip_space=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:526 + def token; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:498 + def ungetc(c = T.unsafe(nil)); end + + class << self + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:433 + def debug?; end + end +end + +# , "when" +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:552 +YARD::Parser::Ruby::Legacy::RubyLex::ACCEPTS_COLON = T.let(T.unsafe(nil), Array) + +# Read an input stream character by character. We allow for unlimited +# ungetting of characters just read. +# +# We simplify the implementation greatly by reading the entire input +# into a buffer initially, and then simply traversing it using +# pointers. +# +# We also have to allow for the <i>here document diversion</i>. This +# little gem comes about when the lexer encounters a here +# document. At this point we effectively need to split the input +# stream into two parts: one to read the body of the here document, +# the other to read the rest of the input line where the here +# document was initially encountered. For example, we might have +# +# do_something(<<-A, <<-B) +# stuff +# for +# A +# stuff +# for +# B +# +# When the lexer encounters the <<A, it reads until the end of the +# line, and keeps it around for later. It then reads the body of the +# here document. Once complete, it needs to read the rest of the +# original line, but then skip the here document body. +# +# @private +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:343 +class YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader + # @return [BufferedReader] a new instance of BufferedReader + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:346 + def initialize(content); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:365 + def column; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:419 + def divert_read_from(reserve); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:400 + def get_read; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:369 + def getc; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:388 + def getc_already_read; end + + # Returns the value of attribute line_num. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:344 + def line_num; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:406 + def peek(at); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:415 + def peek_equal(str); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:392 + def ungetc(_ch); end +end + +# , "when" +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:553 +YARD::Parser::Ruby::Legacy::RubyLex::DEINDENT_CLAUSE = T.let(T.unsafe(nil), Array) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:580 +YARD::Parser::Ruby::Legacy::RubyLex::DLtype2Token = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:548 +YARD::Parser::Ruby::Legacy::RubyLex::ENINDENT_CLAUSE = T.let(T.unsafe(nil), Array) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:571 +YARD::Parser::Ruby::Legacy::RubyLex::Ltype2Token = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:555 +YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_LTYPE = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:564 +YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_PAREN = T.let(T.unsafe(nil), Hash) + +# Legacy Ruby parser +# +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:8 +class YARD::Parser::Ruby::Legacy::RubyParser < ::YARD::Parser::Base + # @return [RubyParser] a new instance of RubyParser + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:9 + def initialize(source, _filename); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:26 + def encoding_line; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:22 + def enumerator; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:13 + def parse; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:27 + def shebang_line; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_parser.rb:18 + def tokenize; end +end + +# Legacy lexical tokenizer module. +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:6 +module YARD::Parser::Ruby::Legacy::RubyToken + # @private + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:125 + def Token(token, value = T.unsafe(nil)); end + + # @private + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:119 + def set_token_position(line, char); end + + class << self + # @private + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:275 + def def_token(token_n, super_token = T.unsafe(nil), reading = T.unsafe(nil), *opts); end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:10 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_ARG = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:7 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_BEG = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:13 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_CLASS = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:12 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_DOT = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:9 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_END = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:11 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_FNAME = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:8 +YARD::Parser::Ruby::Legacy::RubyToken::EXPR_MID = T.let(T.unsafe(nil), Symbol) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:308 +YARD::Parser::Ruby::Legacy::RubyToken::NEWLINE_TOKEN = T.let(T.unsafe(nil), YARD::Parser::Ruby::Legacy::RubyToken::TkNL) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::OPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkALIAS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkAMPER < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkANDOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkAREF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkASET < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkASSIGN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkASSOC < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKQUOTE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKSLASH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBACK_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBITAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBITNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBITOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBITXOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBREAK < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# Represents a block +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:54 +class YARD::Parser::Ruby::Legacy::RubyToken::TkBlockContents < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:55 + def text; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCASE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCLASS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCMP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMA < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMENT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkCONSTANT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDEFINED < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDIV < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDOLLAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkDXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkELSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkELSIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkEND_OF_SCRIPT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkENSURE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkEQQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:115 +class YARD::Parser::Ruby::Legacy::RubyToken::TkError < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkFALSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkFID < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkFLOAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkFOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkGEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkGT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkGVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkIDENTIFIER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkIF_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkINTEGER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkIVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# Represents a Ruby identifier +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:72 +class YARD::Parser::Ruby::Legacy::RubyToken::TkId < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # @return [TkId] a new instance of TkId + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:73 + def initialize(line_no, char_no, name); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:77 + def name; end +end + +# Represents a Ruby keyword +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:81 +class YARD::Parser::Ruby::Legacy::RubyToken::TkKW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLABEL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkLT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkMOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkMODULE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkMULT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNEXT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNOTOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNTH_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:63 +class YARD::Parser::Ruby::Legacy::RubyToken::TkNode < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # Returns the value of attribute node. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:64 + def node; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:98 +class YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + # @return [TkOPASGN] a new instance of TkOPASGN + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:99 + def initialize(line_no, char_no, op); end + + # Returns the value of attribute op. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:104 + def op; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkOROP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:92 +class YARD::Parser::Ruby::Legacy::RubyToken::TkOp < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:93 + def name; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkPOW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkQUESTION < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkREDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRESCUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRETRY < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRETURN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkRSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# { reading => token_class } +# { reading => [token_class, *opt] } +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:271 +YARD::Parser::Ruby::Legacy::RubyToken::TkReading2Token = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSELF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSEMICOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSPACE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSTAR < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSUPER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBEG < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBOL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# Represents an end statement +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:59 +class YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:60 + def text; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:272 +YARD::Parser::Ruby::Legacy::RubyToken::TkSymbol2Token = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkTHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkTRUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUNDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp + class << self + def op_name; end + end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:107 +class YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # @return [TkUnknownChar] a new instance of TkUnknownChar + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:108 + def initialize(line_no, char_no, _id); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:112 + def name; end +end + +# Represents a Ruby value +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:85 +class YARD::Parser::Ruby::Legacy::RubyToken::TkVal < ::YARD::Parser::Ruby::Legacy::RubyToken::Token + # @return [TkVal] a new instance of TkVal + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:86 + def initialize(line_no, char_no, value = T.unsafe(nil)); end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkWHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# Represents whitespace +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:68 +class YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TkYIELD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::Tk__FILE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::Tk__LINE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TklBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:281 +class YARD::Parser::Ruby::Legacy::RubyToken::TklEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end + +# Represents a token in the Ruby lexer +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:16 +class YARD::Parser::Ruby::Legacy::RubyToken::Token + # Creates a new Token object + # + # @param line_no [Integer] the line number to initialize the token to + # @param char_no [Integer] the char number to initialize the token to + # @return [Token] a new instance of Token + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:37 + def initialize(line_no, char_no); end + + # @return [Integer] the character number in the file/stream the token + # is located. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:23 + def char_no; end + + # @return [Symbol] the lexical state at the token + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:29 + def lex_state; end + + # @return [Symbol] the lexical state at the token + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:29 + def lex_state=(_arg0); end + + # @return [Integer] the line number in the file/stream the token is + # located. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:19 + def line_no; end + + # Chainable way to sets the text attribute + # + # @param text [String] the new text + # @return [Token] this token object + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:47 + def set_text(text); end + + # @return [String] the token text value + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:26 + def text; end +end + +# @private +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:32 +YARD::Parser::Ruby::Legacy::RubyToken::Token::NO_TEXT = T.let(T.unsafe(nil), String) + +# @private +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/ruby_lex.rb:147 +YARD::Parser::Ruby::Legacy::RubyToken::TokenDefinitions = T.let(T.unsafe(nil), Array) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:4 +class YARD::Parser::Ruby::Legacy::Statement + # @return [Statement] a new instance of Statement + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:14 + def initialize(tokens, block = T.unsafe(nil), comments = T.unsafe(nil)); end + + # Returns the value of attribute block. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:5 + def block; end + + # Returns the value of attribute comments. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:5 + def comments; end + + # Returns the value of attribute comments_hash_flag. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:12 + def comments_hash_flag; end + + # Sets the attribute comments_hash_flag + # + # @param value the value to set the attribute comments_hash_flag to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:12 + def comments_hash_flag=(_arg0); end + + # Returns the value of attribute comments_range. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:6 + def comments_range; end + + # Sets the attribute comments_range + # + # @param value the value to set the attribute comments_range to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:6 + def comments_range=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:21 + def first_line; end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:10 + def group; end + + # @deprecated Groups are now defined by directives + # @see Tags::GroupDirective + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:10 + def group=(_arg0); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:34 + def inspect; end + + # @return [Fixnum] the first line of Ruby source + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:46 + def line; end + + # @return [Range<Fixnum>] the first to last lines of Ruby source + # @since 0.5.4 + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:52 + def line_range; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:41 + def show; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:21 + def signature; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:27 + def source(include_block = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:27 + def to_s(include_block = T.unsafe(nil)); end + + # Returns the value of attribute tokens. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:5 + def tokens; end + + private + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement.rb:58 + def clean_tokens(tokens); end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:4 +class YARD::Parser::Ruby::Legacy::StatementList < ::Array + include ::YARD::Parser::Ruby::Legacy::RubyToken + + # Creates a new statement list + # + # @param content [TokenList, String] the tokens to create the list from + # @return [StatementList] a new instance of StatementList + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:17 + def initialize(content); end + + # Returns the value of attribute encoding_line. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:7 + def encoding_line; end + + # Sets the attribute encoding_line + # + # @param value the value to set the attribute encoding_line to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:7 + def encoding_line=(_arg0); end + + # Returns the value of attribute shebang_line. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:7 + def shebang_line; end + + # Sets the attribute shebang_line + # + # @param value the value to set the attribute shebang_line to. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:7 + def shebang_line=(_arg0); end + + private + + # Handles the balancing of parentheses and blocks + # + # @param tk [RubyToken::Token] the token to process + # @return [Boolean] whether or not the current statement's parentheses and blocks + # are balanced after +tk+ + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:362 + def balances?(tk); end + + # Returns the next statement in the token stream + # + # @return [Statement] the next statement + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:45 + def next_statement; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:34 + def parse_statements; end + + # Returns the next token in the stream that's not a space + # + # @return [RubyToken::Token] the next non-space token + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:388 + def peek_no_space; end + + # Processes a token in a block + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:194 + def process_block_token(tk); end + + # Processes a complex block-opening token; + # that is, a block opener such as +while+ or +for+ + # that is followed by an expression + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:293 + def process_complex_block_opener(tk); end + + # Processes a comment token that comes before a statement + # + # @param tk [RubyToken::Token] the token to process + # @return [Boolean] whether or not +tk+ was processed as an initial comment + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:213 + def process_initial_comment(tk); end + + # Processes a simple block-opening token; + # that is, a block opener such as +begin+ or +do+ + # that isn't followed by an expression + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:268 + def process_simple_block_opener(tk); end + + # Processes a token that closes a statement + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:305 + def process_statement_end(tk); end + + # Processes a single token + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:130 + def process_token(tk); end + + # Adds a token to the current statement, + # unless it's a newline, semicolon, or comment + # + # @param tk [RubyToken::Token] the token to process + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:380 + def push_token(tk); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:111 + def sanitize_block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:96 + def sanitize_statement_end; end +end + +# The following list of tokens will require a block to be opened +# if used at the beginning of a statement. +# +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/statement_list.rb:11 +YARD::Parser::Ruby::Legacy::StatementList::OPEN_BLOCK_TOKENS = T.let(T.unsafe(nil), Array) + +# source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:4 +class YARD::Parser::Ruby::Legacy::TokenList < ::Array + include ::YARD::Parser::Ruby::Legacy::RubyToken + + # @return [TokenList] a new instance of TokenList + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:7 + def initialize(content = T.unsafe(nil)); end + + # @param tokens [TokenList, Token, String] A list of tokens. If the token is a string, it + # is parsed with {RubyLex}. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:21 + def <<(*tokens); end + + # @param tokens [TokenList, Token, String] A list of tokens. If the token is a string, it + # is parsed with {RubyLex}. + # + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:21 + def push(*tokens); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:37 + def squeeze(type = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:11 + def to_s(full_statement = T.unsafe(nil), show_block = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:53 + def convert_token(lex, tk); end + + # source://yard-0.9.28/lib/yard/parser/ruby/legacy/token_list.rb:44 + def parse_content(content); end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:372 +class YARD::Parser::Ruby::LiteralNode < ::YARD::Parser::Ruby::AstNode + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:373 + def literal?; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:541 +class YARD::Parser::Ruby::LoopNode < ::YARD::Parser::Ruby::KeywordNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:544 + def block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:543 + def condition; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:542 + def loop?; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:438 +class YARD::Parser::Ruby::MethodCallNode < ::YARD::Parser::Ruby::AstNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:464 + def block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:462 + def block_param; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:439 + def call?; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:442 + def method_name(name_only = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:440 + def namespace; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:453 + def parameters(include_block_param = T.unsafe(nil)); end + + private + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:474 + def call_has_paren?; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:470 + def index_adjust; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:479 +class YARD::Parser::Ruby::MethodDefinitionNode < ::YARD::Parser::Ruby::AstNode + def block(*_arg0); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:481 + def def?; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:480 + def kw?; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:484 + def method_name(name_only = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:482 + def namespace; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:489 + def parameters(include_block_param = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:495 + def signature; end + + private + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:510 + def index_adjust; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:536 +class YARD::Parser::Ruby::ModuleNode < ::YARD::Parser::Ruby::KeywordNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:538 + def block; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:537 + def module_name; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:380 +class YARD::Parser::Ruby::ParameterNode < ::YARD::Parser::Ruby::AstNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:430 + def args_forward; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:426 + def block_param; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:414 + def double_splat_param; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:396 + def named_params; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:406 + def splat_param; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:410 + def unnamed_end_params; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:385 + def unnamed_optional_params; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:381 + def unnamed_required_params; end +end + +# source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:360 +class YARD::Parser::Ruby::ReferenceNode < ::YARD::Parser::Ruby::AstNode + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:367 + def namespace; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:363 + def path; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/parser/ruby/ast_node.rb:361 + def ref?; end +end + +# Internal parser class +# +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:27 +class YARD::Parser::Ruby::RipperParser < ::Ripper + # @return [RipperParser] a new instance of RipperParser + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:32 + def initialize(source, filename, *args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def ast; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def charno; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def comments; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:29 + def encoding_line; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:64 + def enumerator; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def file; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:68 + def file_encoding; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:29 + def frozen_string_line; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_BEGIN(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_CHAR(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_END(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on___end__(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_alias(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_alias_error(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_arg_ambiguous(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_arg_paren(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_args_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_args_add_block(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_args_add_star(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_args_forward(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_args_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_aryptn(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_assign(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_assign_error(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_assoc_splat(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_backref(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_backtick(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_begin(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_binary(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_block_var(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_blockarg(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_brace_block(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_break(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_call(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_case(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_class(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_class_name_error(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_comma(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_command(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_command_call(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_const(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_const_path_field(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_const_ref(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_cvar(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_def(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_defined(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_defs(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_do_block(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_dot2(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_dot3(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_else(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_elsif(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_embexpr_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_embexpr_end(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_embvar(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_ensure(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_excessed_comma(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_fcall(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_field(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_float(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_for(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_gvar(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_heredoc_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_heredoc_dedent(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_heredoc_end(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_hshptn(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_ident(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_if(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:443 + def on_if_mod(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_ifop(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:216 + def on_ignored_nl(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_ignored_sp(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_imaginary(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_in(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_int(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_ivar(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:203 + def on_kw(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_kwrest_param(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_label_end(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_lbrace(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_lparen(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_magic_comment(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_massign(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_method_add_arg(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_method_add_block(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_mlhs_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_mlhs_add_post(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_mlhs_add_star(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_mlhs_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_mlhs_paren(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_module(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_mrhs_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_mrhs_add_star(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_mrhs_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_mrhs_new_from_args(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_next(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:216 + def on_nl(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_nokw_param(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:203 + def on_op(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_opassign(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_operator_ambiguous(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_param_error(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_paren(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_period(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:468 + def on_qsymbols_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_qsymbols_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:456 + def on_qsymbols_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:468 + def on_qwords_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_qwords_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:456 + def on_qwords_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_rational(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_rbrace(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_redo(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_regexp_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_regexp_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_regexp_end(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_regexp_literal(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_regexp_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_rescue_mod(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_rest_param(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_retry(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_return(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_return0(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_rparen(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_sclass(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_semicolon(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_stmts_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_stmts_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_string_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_string_concat(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_string_dvar(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_string_embexpr(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_super(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_symbeg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_symbol(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_symbol_literal(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:468 + def on_symbols_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_symbols_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:456 + def on_symbols_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_tlambda(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_tlambeg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_top_const_field(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_tstring_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_tstring_content(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_tstring_end(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_undef(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_unless(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:443 + def on_unless_mod(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_until(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:443 + def on_until_mod(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_var_alias(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_var_field(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_var_ref(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:171 + def on_vcall(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_when(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_while(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:443 + def on_while_mod(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_word_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_word_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:468 + def on_words_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:193 + def on_words_beg(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:456 + def on_words_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:182 + def on_words_sep(tok); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:156 + def on_xstring_add(list, item); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_xstring_literal(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:149 + def on_xstring_new(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_yield(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_yield0(*args); end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:164 + def on_zsuper(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:55 + def parse; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def root; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:29 + def shebang_line; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:28 + def tokens; end + + private + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:661 + def add_comment(line, node = T.unsafe(nil), before_node = T.unsafe(nil), into = T.unsafe(nil)); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:265 + def add_token(token, data); end + + # @return [Boolean] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:605 + def comment_starts_line?(charno); end + + # @raise [ParserSyntaxError] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:600 + def compile_error(msg); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:687 + def freeze_tree(node = T.unsafe(nil)); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:614 + def insert_comments; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:371 + def on_aref(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:379 + def on_aref_field(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:385 + def on_array(other); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:346 + def on_assoc_new(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:358 + def on_assoclist_from_args(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:354 + def on_bare_assoc_hash(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:341 + def on_body_stmt(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:341 + def on_bodystmt(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:536 + def on_comment(comment); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:435 + def on_const_path_ref(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:413 + def on_dyna_symbol(sym); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:586 + def on_embdoc(text); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:580 + def on_embdoc_beg(text); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:591 + def on_embdoc_end(text); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:350 + def on_hash(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:528 + def on_label(data); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:491 + def on_lambda(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:403 + def on_lbracket(tok); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:509 + def on_params(*args); end + + # @raise [ParserSyntaxError] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:600 + def on_parse_error(msg); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:337 + def on_program(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:408 + def on_rbracket(tok); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:500 + def on_rescue(exc, *args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:226 + def on_sp(tok); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:495 + def on_string_content(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:478 + def on_string_literal(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:423 + def on_top_const_ref(*args); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:362 + def on_unary(op, val); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:505 + def on_void_stmt; end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:231 + def visit_event(node); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:245 + def visit_event_arr(node); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:253 + def visit_ns_token(token, data, ast_token = T.unsafe(nil)); end +end + +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:133 +YARD::Parser::Ruby::RipperParser::AST_TOKENS = T.let(T.unsafe(nil), Array) + +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:78 +YARD::Parser::Ruby::RipperParser::MAPPINGS = T.let(T.unsafe(nil), Hash) + +# @since 0.5.6 +# +# source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:131 +YARD::Parser::Ruby::RipperParser::REV_MAPPINGS = T.let(T.unsafe(nil), Hash) + +# Ruby 1.9 parser +# +# source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:12 +class YARD::Parser::Ruby::RubyParser < ::YARD::Parser::Base + # @return [RubyParser] a new instance of RubyParser + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:13 + def initialize(source, filename); end + + # Ruby 1.9 parser + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:21 + def encoding_line; end + + # Ruby 1.9 parser + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:19 + def enumerator; end + + # Ruby 1.9 parser + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:22 + def frozen_string_line; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:17 + def parse; end + + # Ruby 1.9 parser + # + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:20 + def shebang_line; end + + # source://yard-0.9.28/lib/yard/parser/ruby/ruby_parser.rb:18 + def tokenize; end +end + +# Supports {#each} enumeration over a source's tokens, yielding +# the token and a possible {CodeObjects::Base} associated with the +# constant or identifier token. +# +# source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:8 +class YARD::Parser::Ruby::TokenResolver + include ::Enumerable + include ::YARD::CodeObjects::NamespaceMapper + + # Creates a token resolver for given source. + # + # @param source [String] the source code to tokenize + # @param namespace [CodeObjects::Base] the object/namespace to resolve from + # @raise [ParserSyntaxError] + # @return [TokenResolver] a new instance of TokenResolver + # + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:16 + def initialize(source, namespace = T.unsafe(nil)); end + + # Iterates over each token, yielding the token and a possible code + # object that is associated with the token. + # + # @example Yielding code objects + # r = TokenResolver.new("A::B::C") + # r.each do |tok, obj| + # if obj + # puts "#{tok[0]} -> #{obj.path.inspect}" + # else + # puts "No object: #{tok.inspect}" + # end + # end + # + # # Prints: + # # :const -> "A" + # # No object: [:op, "::"] + # # :const -> "A::B" + # # No object: [:op, "::"] + # # :const -> "A::B::C" + # @yieldparam token [Array(Symbol,String,Array(Integer,Integer))] the + # current token object being iterated + # @yieldparam object [CodeObjects::Base, nil] the fully qualified code + # object associated with the current token, or nil if there is no object + # for the yielded token. + # + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:46 + def each; end + + protected + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:94 + def last_sep; end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:95 + def last_sep=(v); end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:94 + def next_object; end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:95 + def next_object=(v); end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:94 + def object; end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:95 + def object=(v); end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:94 + def skip_group; end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:95 + def skip_group=(v); end + + private + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:112 + def lookup(toktype, name); end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:134 + def object_resolved_types(obj = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:106 + def pop_state; end + + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:102 + def push_state; end + + class << self + # source://yard-0.9.28/lib/yard/parser/ruby/token_resolver.rb:92 + def state_attr(*attrs); end + end +end + +# Responsible for parsing a source file into the namespace. Parsing +# also invokes handlers to process the parsed statements and generate +# any code objects that may be recognized. +# +# == Custom Parsers +# SourceParser allows custom parsers to be registered and called when +# a certain filetype is recognized. To register a parser and hook it +# up to a set of file extensions, call {register_parser_type} +# +# @see register_parser_type +# @see Handlers::Base +# @see CodeObjects::Base +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:64 +class YARD::Parser::SourceParser + # @overload initialize + # @return [SourceParser] a new instance of SourceParser + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:406 + def initialize(parser_type = T.unsafe(nil), globals1 = T.unsafe(nil), globals2 = T.unsafe(nil)); end + + # @return [String] the contents of the file to be parsed + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:399 + def contents; end + + # @return [String] the filename being parsed by the parser. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:386 + def file; end + + # @return [String] the filename being parsed by the parser. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:386 + def file=(_arg0); end + + # @return [OpenStruct] an open struct containing arbitrary global state + # shared between files and handlers. + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:395 + def globals; end + + # The main parser method. This should not be called directly. Instead, + # use the class methods {parse} and {parse_string}. + # + # @param content [String, #read, Object] the source file to parse + # @return [Object, nil] the parser object used to parse the source + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:418 + def parse(content = T.unsafe(nil)); end + + # @return [Symbol] the parser type associated with the parser instance. + # This should be set by the {#initialize constructor}. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:390 + def parser_type; end + + # Tokenizes but does not parse the block of code using the current {#parser_type} + # + # @param content [String] the block of code to tokenize + # @return [Array] a list of tokens + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:462 + def tokenize(content); end + + private + + # Searches for encoding line and forces encoding + # + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:471 + def convert_encoding(content); end + + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:516 + def parser_class; end + + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:501 + def parser_type=(value); end + + # Guesses the parser type to use depending on the file extension. + # + # @param filename [String] the filename to use to guess the parser type + # @return [Symbol] a parser type that matches the filename + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:509 + def parser_type_for_filename(filename); end + + # Runs a {Handlers::Processor} object to post process the parsed statements. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:491 + def post_process; end + + class << self + # Registers a callback to be called after an individual file is parsed. + # The block passed to this method will be called on subsequent parse + # calls. + # + # To register a callback that is called after the entire list of files + # is processed, see {after_parse_list}. + # + # @example Printing the length of each file after it is parsed + # SourceParser.after_parse_file do |parser| + # puts "#{parser.file} is #{parser.contents.size} characters" + # end + # YARD.parse('lib/**/*.rb') + # # prints: + # "lib/foo.rb is 1240 characters" + # "lib/foo_bar.rb is 248 characters" + # @return [Proc] the yielded block + # @see before_parse_file + # @see after_parse_list + # @since 0.7.0 + # @yield [parser] the yielded block is called once after each file + # that is parsed. This might happen many times for a single codebase. + # @yieldparam parser [SourceParser] the parser object that parsed + # the file. + # @yieldreturn [void] the return value for the block is ignored. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:324 + def after_parse_file(&block); end + + # @return [Array<Proc>] the list of callbacks to be called after + # parsing a file. Should only be used for testing. + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:352 + def after_parse_file_callbacks; end + + # Registers a callback to be called after a list of files is parsed + # via {parse}. The block passed to this method will be called on + # subsequent parse calls. + # + # @example Printing results after parsing occurs + # SourceParser.after_parse_list do + # puts "Finished parsing!" + # end + # YARD.parse + # # Prints "Finished parsing!" after parsing files + # @return [Proc] the yielded block + # @see before_parse_list + # @see before_parse_file + # @since 0.7.0 + # @yield [files, globals] the yielded block is called once before + # parsing all files + # @yieldparam files [Array<String>] the list of files that will be parsed. + # @yieldparam globals [OpenStruct] a global structure to store arbitrary + # state for post processing (see {Handlers::Processor#globals}) + # @yieldreturn [void] the return value for the block is ignored. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:258 + def after_parse_list(&block); end + + # @return [Array<Proc>] the list of callbacks to be called after + # parsing a list of files. Should only be used for testing. + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:338 + def after_parse_list_callbacks; end + + # Registers a callback to be called before an individual file is parsed. + # The block passed to this method will be called on subsequent parse + # calls. + # + # To register a callback that is called before the entire list of files + # is processed, see {before_parse_list}. + # + # @example Cancel parsing of any test_*.rb files + # SourceParser.before_parse_file do |parser| + # return false if parser.file =~ /^test_.+\.rb$/ + # end + # @example Installing a simple callback + # SourceParser.before_parse_file do |parser| + # puts "I'm parsing #{parser.file}" + # end + # YARD.parse('lib/**/*.rb') + # # prints: + # "I'm parsing lib/foo.rb" + # "I'm parsing lib/foo_bar.rb" + # "I'm parsing lib/last_file.rb" + # @return [Proc] the yielded block + # @see before_parse_list + # @see after_parse_file + # @since 0.7.0 + # @yield [parser] the yielded block is called once before each + # file that is parsed. This might happen many times for a single + # codebase. + # @yieldparam parser [SourceParser] the parser object that will {#parse} + # the file. + # @yieldreturn [Boolean] if the block returns +false+, parsing for + # the file is cancelled. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:295 + def before_parse_file(&block); end + + # @return [Array<Proc>] the list of callbacks to be called before + # parsing a file. Should only be used for testing. + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:345 + def before_parse_file_callbacks; end + + # Registers a callback to be called before a list of files is parsed + # via {parse}. The block passed to this method will be called on + # subsequent parse calls. + # + # @example Setting global state + # SourceParser.before_parse_list do |files, globals| + # globals.method_count = 0 + # end + # SourceParser.after_parse_list do |files, globals| + # puts "Found #{globals.method_count} methods" + # end + # class MyCountHandler < Handlers::Ruby::Base + # handles :def, :defs + # process { globals.method_count += 1 } + # end + # YARD.parse + # # Prints: "Found 37 methods" + # @example Installing a simple callback + # SourceParser.before_parse_list do |files, globals| + # puts "Starting to parse..." + # end + # YARD.parse('lib/**/*.rb') + # # prints "Starting to parse..." + # @example Using a global callback to cancel parsing + # SourceParser.before_parse_list do |files, globals| + # return false if files.include?('foo.rb') + # end + # + # YARD.parse(['foo.rb', 'bar.rb']) # callback cancels this method + # YARD.parse('bar.rb') # parses normally + # @return [Proc] the yielded block + # @see before_parse_file + # @see after_parse_list + # @since 0.7.0 + # @yield [files, globals] the yielded block is called once before + # parsing all files + # @yieldparam files [Array<String>] the list of files that will be parsed. + # @yieldparam globals [OpenStruct] a global structure to store arbitrary + # state for post processing (see {Handlers::Processor#globals}) + # @yieldreturn [Boolean] if the block returns +false+, parsing is + # cancelled. + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:234 + def before_parse_list(&block); end + + # @return [Array<Proc>] the list of callbacks to be called before + # parsing a list of files. Should only be used for testing. + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:331 + def before_parse_list_callbacks; end + + # Parses a path or set of paths + # + # @param paths [String, Array<String>] a path, glob, or list of paths to + # parse + # @param excluded [Array<String, Regexp>] a list of excluded path matchers + # @param level [Fixnum] the logger level to use during parsing. See + # {YARD::Logger} + # @return [void] + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:100 + def parse(paths = T.unsafe(nil), excluded = T.unsafe(nil), level = T.unsafe(nil)); end + + # Parses a string +content+ + # + # @param content [String] the block of code to parse + # @param ptype [Symbol] the parser type to use. See {parser_type}. + # @return the parser object that was used to parse +content+ + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:123 + def parse_string(content, ptype = T.unsafe(nil)); end + + # @return [Symbol] the default parser type (defaults to :ruby) + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:86 + def parser_type; end + + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:88 + def parser_type=(value); end + + # @private + # @return [Hash] a list of registered parser type extensions + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:163 + def parser_type_extensions; end + + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:164 + def parser_type_extensions=(value); end + + # Finds a parser type that is registered for the extension. If no + # type is found, the default Ruby type is returned. + # + # @return [Symbol] the parser type to be used for the extension + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:171 + def parser_type_for_extension(extension); end + + # @private + # @return [Hash{Symbol=>Object}] a list of registered parser types + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:157 + def parser_types; end + + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:158 + def parser_types=(value); end + + # Registers a new parser type. + # + # @example Registering a parser for "java" files + # SourceParser.register_parser_type :java, JavaParser, 'java' + # @param type [Symbol] a symbolic name for the parser type + # @param parser_klass [Base] a class that implements parsing and tokenization + # @param extensions [Array<String>, String, Regexp] a list of extensions or a + # regex to match against the file extension + # @return [void] + # @see Parser::Base + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:146 + def register_parser_type(type, parser_klass, extensions = T.unsafe(nil)); end + + # Tokenizes but does not parse the block of code + # + # @param content [String] the block of code to tokenize + # @param ptype [Symbol] the parser type to use. See {parser_type}. + # @return [Array] a list of tokens + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:132 + def tokenize(content, ptype = T.unsafe(nil)); end + + # Returns the validated parser type. Basically, enforces that :ruby + # type is never set if the Ripper library is not available + # + # @param type [Symbol] the parser type to set + # @private + # @return [Symbol] the validated parser type + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:184 + def validated_parser_type(type); end + + private + + # Parses a list of files in a queue. + # + # @param files [Array<String>] a list of files to queue for parsing + # @return [void] + # + # source://yard-0.9.28/lib/yard/parser/source_parser.rb:364 + def parse_in_order(*files); end + end +end + +# The default glob of files to be parsed. +# +# @since 0.9.0 +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:71 +YARD::Parser::SourceParser::DEFAULT_PATH_GLOB = T.let(T.unsafe(nil), Array) + +# Byte order marks for various encodings +# +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:75 +YARD::Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS = T.let(T.unsafe(nil), Hash) + +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:66 +YARD::Parser::SourceParser::ENCODING_LINE = T.let(T.unsafe(nil), Regexp) + +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:67 +YARD::Parser::SourceParser::FROZEN_STRING_LINE = T.let(T.unsafe(nil), Regexp) + +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:65 +YARD::Parser::SourceParser::SHEBANG_LINE = T.let(T.unsafe(nil), Regexp) + +# Raised when an object is recognized but cannot be documented. This +# generally occurs when the Ruby syntax used to declare an object is +# too dynamic in nature. +# +# source://yard-0.9.28/lib/yard/parser/source_parser.rb:10 +class YARD::Parser::UndocumentableError < ::RuntimeError; end + +# The root path for YARD source libraries +# +# source://yard-0.9.28/lib/yard.rb:4 +YARD::ROOT = T.let(T.unsafe(nil), String) + +# Holds Rake tasks used by YARD +# +# source://yard-0.9.28/lib/yard/autoload.rb:192 +module YARD::Rake; end + +# The rake task to run {CLI::Yardoc} and generate documentation. +# +# source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:10 +class YARD::Rake::YardocTask < ::Rake::TaskLib + # Creates a new task with name +name+. + # + # @param name [String, Symbol] the name of the rake task + # @return [YardocTask] a new instance of YardocTask + # @yield a block to allow any options to be modified on the task + # @yieldparam _self [YardocTask] the task object to allow any parameters + # to be changed. + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:50 + def initialize(name = T.unsafe(nil)); end + + # Runs a +Proc+ after the task + # + # @return [Proc] a proc to call after running the task + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:36 + def after; end + + # Runs a +Proc+ after the task + # + # @return [Proc] a proc to call after running the task + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:36 + def after=(_arg0); end + + # Runs a +Proc+ before the task + # + # @return [Proc] a proc to call before running the task + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:32 + def before; end + + # Runs a +Proc+ before the task + # + # @return [Proc] a proc to call before running the task + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:32 + def before=(_arg0); end + + # The Ruby source files (and any extra documentation files separated by '-') + # to process. + # + # @example Task files assignment + # YARD::Rake::YardocTask.new do |t| + # t.files = ['app/**/*.rb', 'lib/**/*.rb', '-', 'doc/FAQ.md', 'doc/Changes.md'] + # end + # @return [Array<String>] a list of files + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:28 + def files; end + + # The Ruby source files (and any extra documentation files separated by '-') + # to process. + # + # @example Task files assignment + # YARD::Rake::YardocTask.new do |t| + # t.files = ['app/**/*.rb', 'lib/**/*.rb', '-', 'doc/FAQ.md', 'doc/Changes.md'] + # end + # @return [Array<String>] a list of files + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:28 + def files=(_arg0); end + + # The name of the task + # + # @return [String] the task name + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:11 + def name; end + + # The name of the task + # + # @return [String] the task name + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:11 + def name=(_arg0); end + + # Options to pass to {CLI::Yardoc} + # + # @return [Array<String>] the options passed to the commandline utility + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:15 + def options; end + + # Options to pass to {CLI::Yardoc} + # + # @return [Array<String>] the options passed to the commandline utility + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:15 + def options=(_arg0); end + + # Options to pass to {CLI::Stats} + # + # @return [Array<String>] the options passed to the stats utility + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:19 + def stats_options; end + + # Options to pass to {CLI::Stats} + # + # @return [Array<String>] the options passed to the stats utility + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:19 + def stats_options=(_arg0); end + + # @return [Verifier, Proc] an optional {Verifier} to run against all objects + # being generated. Any object that the verifier returns false for will be + # excluded from documentation. This attribute can also be a lambda. + # @see Verifier + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:42 + def verifier; end + + # @return [Verifier, Proc] an optional {Verifier} to run against all objects + # being generated. Any object that the verifier returns false for will be + # excluded from documentation. This attribute can also be a lambda. + # @see Verifier + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:42 + def verifier=(_arg0); end + + protected + + # Defines the rake task + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/rake/yardoc_task.rb:68 + def define; end +end + +# The +Registry+ is the centralized data store for all {CodeObjects} created +# during parsing. The storage is a key value store with the object's path +# (see {CodeObjects::Base#path}) as the key and the object itself as the value. +# Object paths must be unique to be stored in the Registry. All lookups for +# objects are done on the singleton Registry instance using the {Registry.at} +# or {Registry.resolve} methods. +# +# == Saving / Loading a Registry +# The registry is saved to a "yardoc file" (actually a directory), which can +# be loaded back to perform any lookups. See {Registry.load!} and +# {Registry.save} for information on saving and loading of a yardoc file. +# +# == Threading Notes +# The registry class is a singleton class that is accessed directly in many +# places across YARD. To mitigate threading issues, YARD (0.6.5+) makes +# the Registry thread local. This means all access to a registry for a specific +# object set must occur in the originating thread. +# +# @example Loading the Registry +# Registry.load!('/path/to/yardocfile') # loads all objects into memory +# Registry.at('YARD::CodeObjects::Base').docstring +# # => "+Base+ is the superclass of all code objects ..." +# @example Getting an object by a specific path +# Registry.at('YARD::CodeObjects::Base#docstring') +# @example Performing a lookup on a method anywhere in the inheritance tree +# Registry.resolve(P('YARD::CodeObjects::Base'), '#docstring', true) +# +# source://yard-0.9.28/lib/yard/registry.rb:32 +module YARD::Registry + extend ::Enumerable + + class << self + # Returns the object at a specific path. + # + # @param path [String, :root] the pathname to look for. If +path+ is +root+, + # returns the {root} object. + # @return [CodeObjects::Base] the object at path + # @return [nil] if no object is found + # + # source://yard-0.9.28/lib/yard/registry.rb:261 + def [](path); end + + # Returns all objects in the registry that match one of the types provided + # in the +types+ list (if +types+ is provided). + # + # @example Returns all objects + # Registry.all + # @example Returns all classes and modules + # Registry.all(:class, :module) + # @param types [Array<Symbol>] an optional list of types to narrow the + # objects down by. Equivalent to performing a select: + # +Registry.all.select {|o| types.include(o.type) }+ + # @return [Array<CodeObjects::Base>] the list of objects found + # @see CodeObjects::Base#type + # + # source://yard-0.9.28/lib/yard/registry.rb:237 + def all(*types); end + + # Returns the object at a specific path. + # + # @param path [String, :root] the pathname to look for. If +path+ is +root+, + # returns the {root} object. + # @return [CodeObjects::Base] the object at path + # @return [nil] if no object is found + # + # source://yard-0.9.28/lib/yard/registry.rb:261 + def at(path); end + + # @param data [String] data to checksum + # @return [String] the SHA1 checksum for data + # + # source://yard-0.9.28/lib/yard/registry.rb:318 + def checksum_for(data); end + + # @return [Hash{String => String}] a set of checksums for files + # + # source://yard-0.9.28/lib/yard/registry.rb:312 + def checksums; end + + # Clears the registry + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/registry.rb:200 + def clear; end + + # Deletes an object from the registry + # + # @param object [CodeObjects::Base] the object to remove + # @return [void] + # + # source://yard-0.9.28/lib/yard/registry.rb:194 + def delete(object); end + + # Deletes the yardoc file from disk + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/registry.rb:176 + def delete_from_disk; end + + # Iterates over {all} with no arguments + # + # source://yard-0.9.28/lib/yard/registry.rb:221 + def each(&block); end + + # The registry singleton instance. + # + # @deprecated use Registry.methodname directly. + # @return [Registry] returns the registry instance + # + # source://yard-0.9.28/lib/yard/registry.rb:363 + def instance; end + + # Loads the registry and/or parses a list of files + # + # @example Loads the yardoc file or parses files 'a', 'b' and 'c' (but not both) + # Registry.load(['a', 'b', 'c']) + # @example Reparses files 'a' and 'b' regardless of whether yardoc file exists + # Registry.load(['a', 'b'], true) + # @param files [String, Array] if +files+ is an Array, it should represent + # a list of files that YARD should parse into the registry. If reload is + # set to false and the yardoc file already exists, these files are skipped. + # If files is a String, it should represent the yardoc file to load + # into the registry. + # @param reparse [Boolean] if reparse is false and a yardoc file already + # exists, any files passed in will be ignored. + # @raise [ArgumentError] if files is not a String or Array + # @return [Registry] the registry object (for chaining) + # + # source://yard-0.9.28/lib/yard/registry.rb:109 + def load(files = T.unsafe(nil), reparse = T.unsafe(nil)); end + + # Loads a yardoc file and forces all objects cached on disk into + # memory. Equivalent to calling {load_yardoc} followed by {load_all} + # + # @param file [String] the yardoc file to load + # @return [Registry] the registry object (for chaining) + # @see #load_yardoc + # @see #load_all + # @since 0.5.1 + # + # source://yard-0.9.28/lib/yard/registry.rb:144 + def load!(file = T.unsafe(nil)); end + + # Forces all objects cached on disk into memory + # + # @example Loads all objects from disk + # Registry.load + # Registry.all.count #=> 0 + # Registry.load_all + # Registry.all.count #=> 17 + # @return [Registry] the registry object (for chaining) + # @since 0.5.1 + # + # source://yard-0.9.28/lib/yard/registry.rb:159 + def load_all; end + + # Loads a yardoc file directly + # + # @param file [String] the yardoc file to load. + # @return [Registry] the registry object (for chaining) + # + # source://yard-0.9.28/lib/yard/registry.rb:130 + def load_yardoc(file = T.unsafe(nil)); end + + # @param name [String] the locale name. + # @return [I18n::Locale] the locale object for +name+. + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/registry.rb:271 + def locale(name); end + + # Creates a pessmistic transactional lock on the database for writing. + # Use with {YARD.parse} to ensure the database is not written multiple + # times. + # + # @see locked_for_writing? + # + # source://yard-0.9.28/lib/yard/registry.rb:209 + def lock_for_writing(file = T.unsafe(nil), &block); end + + # @return [Boolean] whether the database is currently locked for writing + # + # source://yard-0.9.28/lib/yard/registry.rb:214 + def locked_for_writing?(file = T.unsafe(nil)); end + + # Returns the paths of all of the objects in the registry. + # + # @param reload [Boolean] whether to load entire database + # @return [Array<String>] all of the paths in the registry. + # + # source://yard-0.9.28/lib/yard/registry.rb:252 + def paths(reload = T.unsafe(nil)); end + + # Gets/sets the directory that has LANG.po files + # + # @return [String] the directory that has .po files + # + # source://yard-0.9.28/lib/yard/registry.rb:353 + def po_dir; end + + # Gets/sets the directory that has LANG.po files + # + # @return [String] the directory that has .po files + # + # source://yard-0.9.28/lib/yard/registry.rb:351 + def po_dir=(dir); end + + # The assumed types of a list of paths. This method is used by CodeObjects::Base + # + # @deprecated The registry no longer globally tracks proxy types. + # @private + # @return [{String => Symbol}] a set of unresolved paths and their assumed type + # + # source://yard-0.9.28/lib/yard/registry.rb:341 + def proxy_types; end + + # Registers a new object with the registry + # + # @param object [CodeObjects::Base] the object to register + # @return [CodeObjects::Base] the registered object + # + # source://yard-0.9.28/lib/yard/registry.rb:186 + def register(object); end + + # Attempts to find an object by name starting at +namespace+, performing + # a lookup similar to Ruby's method of resolving a constant in a namespace. + # + # @example Looks for a constant in the root namespace + # Registry.resolve(nil, 'CONSTANT') + # @example Looks for a class method respecting the inheritance tree + # Registry.resolve(myclass, 'mymethod', true) + # @example Looks for instance method #reverse starting from A::B::C + # Registry.resolve(P("A::B::C"), "#reverse") + # @example Looks for a constant but returns a proxy if not found + # Registry.resolve(P('A::B::C'), 'D', false, true) # => #<yardoc proxy A::B::C::D> + # @example Looks for a complex path from a namespace + # Registry.resolve(P('A::B'), 'B::D') # => #<yardoc class A::B::D> + # @param inheritance [Boolean] Follows inheritance chain (mixins, superclass) + # when performing name resolution if set to +true+. + # @param namespace [CodeObjects::NamespaceObject, nil] the starting namespace + # (module or class). If +nil+ or +:root+, starts from the {root} object. + # @param name [String, Symbol] the name (or complex path) to look for from + # +namespace+. + # @param proxy_fallback [Boolean] If +true+, returns a proxy representing + # the unresolved path (namespace + name) if no object is found. + # @param type [Symbol, nil] the {CodeObjects::Base#type} that the resolved + # object must be equal to. No type checking if nil. + # @return [CodeObjects::Base] the object if it is found + # @return [CodeObjects::Proxy] a Proxy representing the object if + # +proxy_fallback+ is +true+. + # @return [nil] if +proxy_fallback+ is +false+ and no object was found. + # @see P + # + # source://yard-0.9.28/lib/yard/registry.rb:303 + def resolve(namespace, name, inheritance = T.unsafe(nil), proxy_fallback = T.unsafe(nil), type = T.unsafe(nil)); end + + # The root namespace object. + # + # @return [CodeObjects::RootObject] the root object in the namespace + # + # source://yard-0.9.28/lib/yard/registry.rb:266 + def root; end + + # Saves the registry to +file+ + # + # @param file [String] the yardoc file to save to + # @return [Boolean] true if the file was saved + # + # source://yard-0.9.28/lib/yard/registry.rb:170 + def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end + + # Whether or not the Registry storage should load everything into a + # single object database (for disk efficiency), or spread them out + # (for load time efficiency). + # + # @note Setting this attribute to nil will offload the decision to + # the {RegistryStore storage adapter}. + # @return [Boolean, nil] if this value is set to nil, the storage + # adapter will decide how to store the data. + # + # source://yard-0.9.28/lib/yard/registry.rb:335 + def single_object_db; end + + # Whether or not the Registry storage should load everything into a + # single object database (for disk efficiency), or spread them out + # (for load time efficiency). + # + # @note Setting this attribute to nil will offload the decision to + # the {RegistryStore storage adapter}. + # @return [Boolean, nil] if this value is set to nil, the storage + # adapter will decide how to store the data. + # + # source://yard-0.9.28/lib/yard/registry.rb:334 + def single_object_db=(v); end + + # Gets/sets the yardoc filename + # + # @return [String] the yardoc filename + # @see DEFAULT_YARDOC_FILE + # + # source://yard-0.9.28/lib/yard/registry.rb:88 + def yardoc_file; end + + # Gets/sets the yardoc filename + # + # @return [String] the yardoc filename + # @see DEFAULT_YARDOC_FILE + # + # source://yard-0.9.28/lib/yard/registry.rb:86 + def yardoc_file=(v); end + + # Returns the .yardoc file associated with a gem. + # + # @param gem [String] the name of the gem to search for + # @param ver_require [String] an optional Gem version requirement + # @param for_writing [Boolean] whether or not the method should search + # for writable locations + # @return [String] if +for_writing+ is set to +true+, returns the best + # location suitable to write the .yardoc file. Otherwise, the first + # existing location associated with the gem's .yardoc file. + # @return [nil] if +for_writing+ is set to false and no yardoc file + # is found, returns nil. + # + # source://yard-0.9.28/lib/yard/registry.rb:53 + def yardoc_file_for_gem(gem, ver_require = T.unsafe(nil), for_writing = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/registry.rb:390 + def global_yardoc_file(spec, for_writing = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/registry.rb:410 + def local_yardoc_file(spec, for_writing = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/registry.rb:403 + def old_global_yardoc_file(spec, for_writing = T.unsafe(nil)); end + + # Attempts to resolve a name in a namespace + # + # @param namespace [CodeObjects::NamespaceObject] the starting namespace + # @param name [String] the name to look for + # @param type [Symbol, nil] the {CodeObjects::Base#type} that the resolved + # object must be equal to + # + # source://yard-0.9.28/lib/yard/registry.rb:375 + def partial_resolve(namespace, name, type = T.unsafe(nil)); end + + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry.rb:434 + def thread_local_resolver; end + + # @since 0.6.5 + # + # source://yard-0.9.28/lib/yard/registry.rb:424 + def thread_local_store; end + + # @since 0.6.5 + # + # source://yard-0.9.28/lib/yard/registry.rb:429 + def thread_local_store=(value); end + end +end + +# source://yard-0.9.28/lib/yard/registry.rb:35 +YARD::Registry::DEFAULT_PO_DIR = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/registry.rb:33 +YARD::Registry::DEFAULT_YARDOC_FILE = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/registry.rb:34 +YARD::Registry::LOCAL_YARDOC_INDEX = T.let(T.unsafe(nil), String) + +# Handles all logic for complex lexical and inherited object resolution. +# Used by {Registry.resolve}, so there is no need to use this class +# directly. +# +# @see Registry.resolve +# @since 0.9.1 +# +# source://yard-0.9.28/lib/yard/registry_resolver.rb:9 +class YARD::RegistryResolver + include ::YARD::CodeObjects::NamespaceMapper + + # Creates a new resolver object for a registry. + # + # @param registry [Registry] only set this if customizing the registry + # object + # @return [RegistryResolver] a new instance of RegistryResolver + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:16 + def initialize(registry = T.unsafe(nil)); end + + # Performs a lookup on a given path in the registry. Resolution will occur + # in a similar way to standard Ruby identifier resolution, doing lexical + # lookup, as well as (optionally) through the inheritance chain. A proxy + # object can be returned if the lookup fails for future resolution. The + # proxy will be type hinted with the +type+ used in the original lookup. + # + # @example A lookup on a method through the inheritance tree + # resolver.lookup_by_math("A::B#foo", inheritance: true) + # @example A lookup from root + # resolver.lookup_by_path("A::B::C") + # @example A lookup from the A::B namespace + # resolver.lookup_by_path("C", namespace: P("A::B")) + # @option opts + # @option opts + # @option opts + # @option opts + # @param opts [Hash] a customizable set of options + # @return [CodeObjects::Base, CodeObjects::Proxy, nil] the first object + # that matches the path lookup. If proxy_fallback is provided, a proxy + # object will be returned in the event of no match, otherwise nil will + # be returned. + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:50 + def lookup_by_path(path, opts = T.unsafe(nil)); end + + private + + # Collects and returns all inherited namespaces for a given object + # + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:180 + def collect_namespaces(object); end + + # Performs a lexical lookup from a namespace for a path and a type hint. + # + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:104 + def lookup_path_direct(namespace, path, type); end + + # Performs a lookup through the inheritance chain on a path with a type hint. + # + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:121 + def lookup_path_inherited(namespace, path, type); end + + # @return [Regexp] the regexp that can be used to split a string on all + # occurrences of separator tokens + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:205 + def split_on_separators_match; end + + # @return [Regexp] the regexp match of the default separator + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:193 + def starts_with_default_separator_match; end + + # @return [Regexp] the regexp that matches strings starting with + # a separator + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:199 + def starts_with_separator_match; end + + # return [Boolean] if the obj's type matches the provided type. + # + # @since 0.9.1 + # + # source://yard-0.9.28/lib/yard/registry_resolver.rb:99 + def validate(obj, type); end +end + +# The data store for the {Registry}. +# +# @see Registry +# @see Serializers::YardocSerializer +# +# source://yard-0.9.28/lib/yard/registry_store.rb:9 +class YARD::RegistryStore + # @return [RegistryStore] a new instance of RegistryStore + # + # source://yard-0.9.28/lib/yard/registry_store.rb:14 + def initialize; end + + # Gets a {CodeObjects::Base} from the store + # + # @param key [String, Symbol] the path name of the object to look for. + # If it is empty or :root, returns the {#root} object. + # @return [CodeObjects::Base, nil] a code object or nil if none is found + # + # source://yard-0.9.28/lib/yard/registry_store.rb:33 + def [](key); end + + # Associates an object with a path + # + # @param key [String, Symbol] the path name (:root or '' for root object) + # @param value [CodeObjects::Base] the object to store + # @return [CodeObjects::Base] returns +value+ + # + # source://yard-0.9.28/lib/yard/registry_store.rb:55 + def []=(key, value); end + + # Returns the value of attribute checksums. + # + # source://yard-0.9.28/lib/yard/registry_store.rb:12 + def checksums; end + + # Deletes an object at a given path + # + # @param key [#to_sym] the key to delete + # @return [void] + # + # source://yard-0.9.28/lib/yard/registry_store.rb:75 + def delete(key); end + + # Deletes the .yardoc database on disk + # + # @param force [Boolean] if force is not set to true, the file/directory + # will only be removed if it ends with .yardoc. This helps with + # cases where the directory might have been named incorrectly. + # @return [Boolean] true if the .yardoc database was deleted, false + # otherwise. + # + # source://yard-0.9.28/lib/yard/registry_store.rb:218 + def destroy(force = T.unsafe(nil)); end + + # Returns the value of attribute file. + # + # source://yard-0.9.28/lib/yard/registry_store.rb:12 + def file; end + + # Gets a {CodeObjects::Base} from the store + # + # @param key [String, Symbol] the path name of the object to look for. + # If it is empty or :root, returns the {#root} object. + # @return [CodeObjects::Base, nil] a code object or nil if none is found + # + # source://yard-0.9.28/lib/yard/registry_store.rb:33 + def get(key); end + + # Gets all path names from the store. Loads the entire database + # if +reload+ is +true+ + # + # @param reload [Boolean] if false, does not load the entire database + # before a lookup. + # @return [Array<Symbol>] the path names of all the code objects + # + # source://yard-0.9.28/lib/yard/registry_store.rb:88 + def keys(reload = T.unsafe(nil)); end + + # @param file [String, nil] the name of the yardoc db to load + # @return [Boolean] whether the database was loaded + # + # source://yard-0.9.28/lib/yard/registry_store.rb:128 + def load(file = T.unsafe(nil)); end + + # Loads the .yardoc file and loads all cached objects into memory + # automatically. + # + # @param file [String, nil] the name of the yardoc db to load + # @return [Boolean] whether the database was loaded + # @see #load_all + # @since 0.5.1 + # + # source://yard-0.9.28/lib/yard/registry_store.rb:142 + def load!(file = T.unsafe(nil)); end + + # Loads all cached objects into memory + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/registry_store.rb:153 + def load_all; end + + # @param name [String] the locale name. + # @return [I18n::Locale] the locale object for +name+. + # @since 0.8.3 + # + # source://yard-0.9.28/lib/yard/registry_store.rb:122 + def locale(name); end + + # Creates a pessmistic transactional lock on the database for writing. + # Use with {YARD.parse} to ensure the database is not written multiple + # times. + # + # @param file [String] if supplied, the path to the database + # @see #locked_for_writing? + # + # source://yard-0.9.28/lib/yard/registry_store.rb:201 + def lock_for_writing(file = T.unsafe(nil), &block); end + + # @param file [String] if supplied, the path to the database + # @return [Boolean] whether the database is currently locked for writing + # + # source://yard-0.9.28/lib/yard/registry_store.rb:207 + def locked_for_writing?(file = T.unsafe(nil)); end + + # @param type [Symbol] the type to look for + # @return [Array<String>] a list of object paths with a given + # {CodeObjects::Base#type} + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/registry_store.rb:102 + def paths_for_type(type, reload = T.unsafe(nil)); end + + # @deprecated The registry no longer tracks proxy types + # + # source://yard-0.9.28/lib/yard/registry_store.rb:11 + def proxy_types; end + + # Associates an object with a path + # + # @param key [String, Symbol] the path name (:root or '' for root object) + # @param value [CodeObjects::Base] the object to store + # @return [CodeObjects::Base] returns +value+ + # + # source://yard-0.9.28/lib/yard/registry_store.rb:55 + def put(key, value); end + + # @return [CodeObjects::RootObject] the root object + # + # source://yard-0.9.28/lib/yard/registry_store.rb:117 + def root; end + + # Saves the database to disk + # + # @param merge [Boolean] if true, merges the data in memory with the + # data on disk, otherwise the data on disk is deleted. + # @param file [String, nil] if supplied, the name of the file to save to + # @return [Boolean] whether the database was saved + # + # source://yard-0.9.28/lib/yard/registry_store.rb:177 + def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end + + # Gets all code objects from the store. Loads the entire database + # if +reload+ is +true+ + # + # @param reload [Boolean] if false, does not load the entire database + # before a lookup. + # @return [Array<CodeObjects::Base>] all the code objects + # + # source://yard-0.9.28/lib/yard/registry_store.rb:96 + def values(reload = T.unsafe(nil)); end + + # @param type [Symbol] the type to look for + # @return [Array<CodeObjects::Base>] a list of objects with a given + # {CodeObjects::Base#type} + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/registry_store.rb:111 + def values_for_type(type, reload = T.unsafe(nil)); end + + protected + + # source://yard-0.9.28/lib/yard/registry_store.rb:243 + def checksums_path; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:251 + def load_yardoc; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:247 + def object_types_path; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:234 + def objects_path; end + + # @deprecated The registry no longer tracks proxy types + # + # source://yard-0.9.28/lib/yard/registry_store.rb:239 + def proxy_types_path; end + + private + + # source://yard-0.9.28/lib/yard/registry_store.rb:319 + def all_disk_objects; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:291 + def load_checksums; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:313 + def load_locale(name); end + + # source://yard-0.9.28/lib/yard/registry_store.rb:281 + def load_object_types; end + + # @deprecated The registry no longer tracks proxy types + # + # source://yard-0.9.28/lib/yard/registry_store.rb:276 + def load_proxy_types; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:299 + def load_root; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:271 + def load_yardoc_old; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:332 + def write_checksums; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:338 + def write_complete_lock; end + + # source://yard-0.9.28/lib/yard/registry_store.rb:328 + def write_object_types; end + + # @deprecated The registry no longer tracks proxy types + # + # source://yard-0.9.28/lib/yard/registry_store.rb:324 + def write_proxy_types; end +end + +# Namespace for components that serialize to various endpoints +# +# source://yard-0.9.28/lib/yard/autoload.rb:196 +module YARD::Serializers; end + +# The abstract base serializer. Serializers allow templates to be +# rendered to various endpoints. For instance, a {FileSystemSerializer} +# would allow template contents to be written to the filesystem +# +# To implement a custom serializer, override the following methods: +# * {#serialize} +# * {#serialized_path} +# +# Optionally, a serializer can implement before and after filters: +# * {#before_serialize} +# * {#after_serialize} +# +# @abstract Override this class to implement a custom serializer. +# +# source://yard-0.9.28/lib/yard/serializers/base.rb:17 +class YARD::Serializers::Base + # Creates a new serializer with options + # + # @param opts [Hash] the options to assign to {#options} + # @return [Base] a new instance of Base + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:28 + def initialize(opts = T.unsafe(nil)); end + + # Called after serialization. + # + # @abstract Should run code after serialization. + # @param data [String] the data that was serialized. + # @return [void] + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:80 + def after_serialize(data); end + + # Called before serialization. + # + # @abstract Should run code before serialization. Should return false + # if serialization should not occur. + # @return [Boolean] whether or not serialization should occur + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:73 + def before_serialize; end + + # Returns whether an object has been serialized + # + # @abstract This method should return whether the endpoint already exists. + # For instance, a file system serializer would check if the file exists + # on disk. You will most likely use +#basepath+ and {#serialized_path} to + # get the endpoint's location. + # @param object [CodeObjects::Base] the object to check existence of + # @return [Boolean] whether the endpoint exists. + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:62 + def exists?(object); end + + # All serializer options are saved so they can be passed to other serializers. + # + # @return [SymbolHash] the serializer options + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:21 + def options; end + + # Serializes an object. + # + # @abstract This method should implement the logic that serializes + # +data+ to the respective endpoint. This method should also call + # the before and after callbacks {#before_serialize} and {#after_serialize} + # @param object [CodeObjects::Base, String] the object to serialize the + # data for. The object can also be a string (for non-object serialization) + # @param data [String] the contents that should be serialized + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:42 + def serialize(object, data); end + + # The serialized path of an object + # + # @abstract This method should return the path of the object on the + # endpoint. For instance, for a file serializer, this should return + # the filename that represents the object on disk. + # @param object [CodeObjects::Base] the object to return a path for + # @return [String] the serialized path of an object + # + # source://yard-0.9.28/lib/yard/serializers/base.rb:51 + def serialized_path(object); end +end + +# Implements a serializer that reads from and writes to the filesystem. +# +# source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:7 +class YARD::Serializers::FileSystemSerializer < ::YARD::Serializers::Base + # Creates a new FileSystemSerializer with options + # + # @option opts + # @option opts + # @param opts [Hash] a customizable set of options + # @return [FileSystemSerializer] a new instance of FileSystemSerializer + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:28 + def initialize(opts = T.unsafe(nil)); end + + # The base path to write data to. + # + # @return [String] a base path + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:8 + def basepath; end + + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:10 + def basepath=(value); end + + # Checks the disk for an object and returns whether it was serialized. + # + # @param object [CodeObjects::Base] the object to check + # @return [Boolean] whether an object has been serialized to disk + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:71 + def exists?(object); end + + # The extension of the filename (defaults to +html+) + # + # @return [String] the extension of the file. Empty string for no extension. + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:17 + def extension; end + + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:19 + def extension=(value); end + + # Serializes object with data to its serialized path (prefixed by the +#basepath+). + # + # @return [String] the written data (for chaining) + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:38 + def serialize(object, data); end + + # Implements the serialized path of a code object. + # + # @param object [CodeObjects::Base, CodeObjects::ExtraFileObject, String] the object to get a path for. The path of a string is the string itself. + # @return [String] if object is a String, returns + # object, otherwise the path on disk (without the basepath). + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:50 + def serialized_path(object); end + + private + + # Builds a filename mapping from object paths to filesystem path names. + # Needed to handle case sensitive YARD objects mapped into a case + # insensitive filesystem. Uses with {#mapped_name} to determine the + # mapping name for a given object. + # + # @note In order to use filesystem name mapping, you must initialize + # the serializer object after preparing the {YARD::Registry}. + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:84 + def build_filename_map; end + + # Remove special chars from filenames. + # Windows disallows \ / : * ? " < > | but we will just remove any + # non alphanumeric (plus period, underscore and dash). + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:111 + def encode_path_components(*components); end + + # @return [String] the filesystem mapped name of a given object. + # + # source://yard-0.9.28/lib/yard/serializers/file_system_serializer.rb:102 + def mapped_name(object); end +end + +# Serializes an object to a process (like less) +# +# @example Serializing to a pager (less) +# serializer = ProcessSerializer.new('less') +# serializer.serialize(object, "data!") +# +# source://yard-0.9.28/lib/yard/serializers/process_serializer.rb:12 +class YARD::Serializers::ProcessSerializer < ::YARD::Serializers::Base + # Creates a new ProcessSerializer for the shell command +cmd+ + # + # @param cmd [String] the command that will accept data on stdin + # @return [ProcessSerializer] a new instance of ProcessSerializer + # + # source://yard-0.9.28/lib/yard/serializers/process_serializer.rb:13 + def initialize(cmd); end + + # Overrides serialize behaviour and writes data to standard input + # of the associated command + # + # source://yard-0.9.28/lib/yard/serializers/process_serializer.rb:19 + def serialize(_object, data); end +end + +# A serializer that writes data to standard output. +# +# source://yard-0.9.28/lib/yard/serializers/stdout_serializer.rb:9 +class YARD::Serializers::StdoutSerializer < ::YARD::Serializers::Base + # Creates a serializer to print text to stdout + # + # @param wrap [Fixnum, nil] if wrap is a number, wraps text to +wrap+ + # columns, otherwise no wrapping is done. + # @return [StdoutSerializer] a new instance of StdoutSerializer + # + # source://yard-0.9.28/lib/yard/serializers/stdout_serializer.rb:10 + def initialize(wrap = T.unsafe(nil)); end + + # Overrides serialize behaviour to write data to standard output + # + # source://yard-0.9.28/lib/yard/serializers/stdout_serializer.rb:15 + def serialize(_object, data); end + + private + + # Wraps text to a specific column length + # + # @param text [String] the text to wrap + # @param _length [Fixnum] the column length to wrap to + # @return [String] the wrapped text + # + # source://yard-0.9.28/lib/yard/serializers/stdout_serializer.rb:26 + def word_wrap(text, _length = T.unsafe(nil)); end +end + +# source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:32 +class YARD::Serializers::YardocSerializer < ::YARD::Serializers::FileSystemSerializer + # @return [YardocSerializer] a new instance of YardocSerializer + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:33 + def initialize(yfile); end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:40 + def checksums_path; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:45 + def complete?; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:42 + def complete_lock_path; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:101 + def deserialize(path, is_path = T.unsafe(nil)); end + + # Creates a pessmistic transactional lock on the database for writing. + # Use with {YARD.parse} to ensure the database is not written multiple + # times. + # + # @see #locked_for_writing? + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:54 + def lock_for_writing; end + + # @return [Boolean] whether the database is currently locked for writing + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:62 + def locked_for_writing?; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:41 + def object_types_path; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:37 + def objects_path; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:43 + def processing_path; end + + # @deprecated The registry no longer tracks proxy types + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:39 + def proxy_types_path; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:93 + def serialize(object); end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:66 + def serialized_path(object); end + + private + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:114 + def dump(object); end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:119 + def internal_dump(object, first_object = T.unsafe(nil)); end +end + +# Namespace for classes and modules that handle serving documentation over HTTP +# +# == Implementing a Custom Server +# To customize the YARD server, see the {Adapter} and {Router} classes. +# +# == Rack Middleware +# If you want to use the YARD server as a Rack middleware, see the documentation +# in {RackMiddleware}. +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/autoload.rb:214 +module YARD::Server + class << self + # Registers a static path to be used in static asset lookup. + # + # @param path [String] the pathname to register + # @return [void] + # @since 0.6.2 + # + # source://yard-0.9.28/lib/yard/server.rb:8 + def register_static_path(path); end + end +end + +# This class implements the bridge between the {Router} and the server +# backend for a specific server type. YARD implements concrete adapters +# for WEBrick and Rack respectively, though other adapters can be made +# for other server architectures. +# +# == Subclassing Notes +# To create a concrete adapter class, implement the {#start} method to +# initiate the server backend. +# +# @abstract +# +# source://yard-0.9.28/lib/yard/server/adapter.rb:23 +class YARD::Server::Adapter + # Creates a new adapter object + # + # @option opts + # @option opts + # @option opts + # @param libs [Hash{String=>Array<LibraryVersion>}] a list of libraries, + # see {#libraries} for formulating this list. + # @param opts [Hash] extra options to pass to the adapter + # @return [Adapter] a new instance of Adapter + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:71 + def initialize(libs, opts = T.unsafe(nil), server_opts = T.unsafe(nil)); end + + # Adds a library to the {#libraries} mapping for a given library object. + # + # @example Adding a new library to an adapter + # adapter.add_library LibraryVersion.new('mylib', '1.0', '/path/to/.yardoc') + # @param library [LibraryVersion] a library to add + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:88 + def add_library(library); end + + # @return [String] the location where static files are located, if any. + # To set this field on initialization, pass +:DocumentRoot+ to the + # +server_opts+ argument in {#initialize} + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:27 + def document_root; end + + # @return [String] the location where static files are located, if any. + # To set this field on initialization, pass +:DocumentRoot+ to the + # +server_opts+ argument in {#initialize} + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:27 + def document_root=(_arg0); end + + # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries. + # @see LibraryVersion LibraryVersion for information on building a list of libraries + # @see #add_library + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:32 + def libraries; end + + # @return [Hash{String=>Array<LibraryVersion>}] a map of libraries. + # @see LibraryVersion LibraryVersion for information on building a list of libraries + # @see #add_library + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:32 + def libraries=(_arg0); end + + # @return [Hash] options passed and processed by adapters. The actual + # options mostly depend on the adapters themselves. + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:36 + def options; end + + # @return [Hash] options passed and processed by adapters. The actual + # options mostly depend on the adapters themselves. + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:36 + def options=(_arg0); end + + # @return [Router] the router object used to route URLs to commands + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:43 + def router; end + + # @return [Router] the router object used to route URLs to commands + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:43 + def router=(_arg0); end + + # @return [Hash] a set of options to pass to the server backend. Note + # that +:DocumentRoot+ also sets the {#document_root}. + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:40 + def server_options; end + + # @return [Hash] a set of options to pass to the server backend. Note + # that +:DocumentRoot+ also sets the {#document_root}. + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:40 + def server_options=(_arg0); end + + # Implement this method to connect your adapter to your server. + # + # @abstract + # @raise [NotImplementedError] + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:95 + def start; end + + class << self + # Performs any global initialization for the adapter. + # + # @note If you subclass this method, make sure to call +super+. + # @return [void] + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:48 + def setup; end + + # Performs any global shutdown procedures for the adapter. + # + # @note If you subclass this method, make sure to call +super+. + # @return [void] + # + # source://yard-0.9.28/lib/yard/server/adapter.rb:56 + def shutdown; end + end +end + +# Commands implement specific kinds of server responses which are routed +# to by the {Router} class. To implement a custom command, subclass {Commands::Base}. +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/autoload.rb:219 +module YARD::Server::Commands; end + +# This is the base command class used to implement custom commands for +# a server. A command will be routed to by the {Router} class and return +# a Rack-style response. +# +# == Attribute Initializers +# All attributes can be initialized via options passed into the {#initialize} +# method. When creating a custom command, the {Adapter#options} will +# automatically be mapped to attributes by the same name on your class. +# +# class MyCommand < Base +# attr_accessor :myattr +# end +# +# Adapter.new(libs, {:myattr => 'foo'}).start +# +# # when a request comes in, cmd.myattr == 'foo' +# +# == Subclassing Notes +# To implement a custom command, override the {#run} method, not {#call}. +# In your implementation, you should set the body and status for requests. +# See details in the +#run+ method documentation. +# +# Note that if your command deals directly with libraries, you should +# consider subclassing the more specific {LibraryCommand} class instead. +# +# @abstract +# @see #run +# +# source://yard-0.9.28/lib/yard/server/commands/base.rb:34 +class YARD::Server::Commands::Base + # Creates a new command object, setting attributes named by keys + # in the options hash. After initialization, the options hash + # is saved in {#command_options} for further inspection. + # + # @example Creating a Command + # cmd = DisplayObjectCommand.new(:caching => true, :library => mylib) + # cmd.library # => mylib + # cmd.command_options # => {:caching => true, :library => mylib} + # @param opts [Hash] the options hash, saved to {#command_options} + # after initialization. + # @return [Base] a new instance of Base + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:75 + def initialize(opts = T.unsafe(nil)); end + + # @return [Adapter] the server adapter + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:41 + def adapter; end + + # @return [Adapter] the server adapter + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:41 + def adapter=(_arg0); end + + # @return [String] the response body. Defaults to empty string. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:61 + def body; end + + # @return [String] the response body. Defaults to empty string. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:61 + def body=(_arg0); end + + # @return [Boolean] whether to cache + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:44 + def caching; end + + # @return [Boolean] whether to cache + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:44 + def caching=(_arg0); end + + # The main method called by a router with a request object. + # + # @note This command should not be overridden by subclasses. Implement + # the callback method {#run} instead. + # @param request [Adapter Dependent] the request object + # @return [Array(Numeric,Hash,Array<String>)] a Rack-style response + # of status, headers, and body wrapped in an array. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:89 + def call(request); end + + # @return [Hash] the options passed to the command's constructor + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:38 + def command_options; end + + # @return [Hash] the options passed to the command's constructor + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:38 + def command_options=(_arg0); end + + # @return [Hash{String => String}] response headers + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:55 + def headers; end + + # @return [Hash{String => String}] response headers + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:55 + def headers=(_arg0); end + + # @return [String] the path after the command base URI + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:52 + def path; end + + # @return [String] the path after the command base URI + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:52 + def path=(_arg0); end + + # @return [Rack::Request] request object + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:49 + def request; end + + # @return [Rack::Request] request object + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:49 + def request=(_arg0); end + + # Subclass this method to implement a custom command. This method + # should set the {#status} and {#body}, and optionally modify the + # {#headers}. Note that +#status+ defaults to 200. + # + # @abstract + # @example A custom command + # class ErrorCommand < Base + # def run + # self.body = 'ERROR! The System is down!' + # self.status = 500 + # self.headers['Conten-Type'] = 'text/plain' + # end + # end + # @raise [NotImplementedError] + # @return [void] + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:128 + def run; end + + # @return [Numeric] status code. Defaults to 200 per request + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:58 + def status; end + + # @return [Numeric] status code. Defaults to 200 per request + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:58 + def status=(_arg0); end + + protected + + # Override this method to implement custom caching mechanisms for + # + # @example Caching to memory + # $memory_cache = {} + # def cache(data) + # $memory_cache[path] = data + # end + # @param data [String] the data to cache + # @return [String] the same cached data (for chaining) + # @see StaticCaching + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:165 + def cache(data); end + + # Sets the body and headers for a 404 response. Does not modify the + # body if already set. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:180 + def not_found; end + + # Sets the headers and status code for a redirection to a given URL + # + # @param url [String] the URL to redirect to + # @raise [FinishRequest] causes the request to terminate. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:192 + def redirect(url); end + + # Renders a specific object if provided, or a regular template rendering + # if object is not provided. + # + # @param object [CodeObjects::Base, nil] calls {CodeObjects::Base#format} if + # an object is provided, or {Templates::Engine.render} if object is nil. Both + # receive +#options+ as an argument. + # @return [String] the resulting output to display + # @todo This method is dependent on +#options+, it should be in {LibraryCommand}. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:144 + def render(object = T.unsafe(nil)); end + + private + + # Add a conservative cache control policy to reduce load on + # requests served with "?1234567890" style timestamp query strings. + # + # source://yard-0.9.28/lib/yard/server/commands/base.rb:202 + def add_cache_control; end +end + +# Displays a README or extra file. +# +# @todo Implement better support for detecting binary (image) filetypes +# +# source://yard-0.9.28/lib/yard/server/commands/display_file_command.rb:8 +class YARD::Server::Commands::DisplayFileCommand < ::YARD::Server::Commands::LibraryCommand + # Returns the value of attribute index. + # + # source://yard-0.9.28/lib/yard/server/commands/display_file_command.rb:9 + def index; end + + # Sets the attribute index + # + # @param value the value to set the attribute index to. + # + # source://yard-0.9.28/lib/yard/server/commands/display_file_command.rb:9 + def index=(_arg0); end + + # @raise [NotFoundError] + # + # source://yard-0.9.28/lib/yard/server/commands/display_file_command.rb:11 + def run; end +end + +# Displays documentation for a specific object identified by the path +# +# source://yard-0.9.28/lib/yard/server/commands/display_object_command.rb:6 +class YARD::Server::Commands::DisplayObjectCommand < ::YARD::Server::Commands::LibraryCommand + include ::YARD::Server::DocServerHelper + + # source://yard-0.9.28/lib/yard/server/commands/display_object_command.rb:36 + def index; end + + # source://yard-0.9.28/lib/yard/server/commands/display_object_command.rb:47 + def not_found; end + + # source://yard-0.9.28/lib/yard/server/commands/display_object_command.rb:9 + def run; end + + private + + # source://yard-0.9.28/lib/yard/server/commands/display_object_command.rb:54 + def object_path; end +end + +# Displays an object wrapped in frames +# +# source://yard-0.9.28/lib/yard/server/commands/frames_command.rb:6 +class YARD::Server::Commands::FramesCommand < ::YARD::Server::Commands::DisplayObjectCommand + # source://yard-0.9.28/lib/yard/server/commands/frames_command.rb:7 + def run; end +end + +# This is the base command for all commands that deal directly with libraries. +# Some commands do not, but most (like {DisplayObjectCommand}) do. If your +# command deals with libraries directly, subclass this class instead. +# See {Base} for notes on how to subclass a command. +# +# @abstract +# +# source://yard-0.9.28/lib/yard/server/commands/library_command.rb:32 +class YARD::Server::Commands::LibraryCommand < ::YARD::Server::Commands::Base + # @return [LibraryCommand] a new instance of LibraryCommand + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:63 + def initialize(opts = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:68 + def call(request); end + + # @return [Boolean] whether to reparse data + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:53 + def incremental; end + + # @return [Boolean] whether to reparse data + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:53 + def incremental=(_arg0); end + + # @return [LibraryVersion] the object containing library information + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:41 + def library; end + + # @return [LibraryVersion] the object containing library information + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:41 + def library=(_arg0); end + + # @return [LibraryOptions] default options for the library + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:44 + def options; end + + # @return [LibraryOptions] default options for the library + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:44 + def options=(_arg0); end + + # @return [Serializers::Base] the serializer used to perform file linking + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:47 + def serializer; end + + # @return [Serializers::Base] the serializer used to perform file linking + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:47 + def serializer=(_arg0); end + + # @return [Boolean] whether router should route for multiple libraries + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:50 + def single_library; end + + # @return [Boolean] whether router should route for multiple libraries + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:50 + def single_library=(_arg0); end + + # @return [Boolean] whether or not this adapter calls +fork+ when serving + # library requests. Defaults to false. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:57 + def use_fork; end + + # @return [Boolean] whether or not this adapter calls +fork+ when serving + # library requests. Defaults to false. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:57 + def use_fork=(_arg0); end + + private + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:96 + def call_with_fork(request, &block); end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:83 + def call_without_fork(request); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:109 + def can_fork?; end + + # Hack to load a custom fulldoc template object that does + # not do any rendering/generation. We need this to access the + # generate_*_list methods. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:171 + def fulldoc_template; end + + # @raise [LibraryNotPreparedError] + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:147 + def load_yardoc; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:159 + def not_prepared; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:118 + def restore_template_info; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:113 + def save_default_template_info; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:123 + def setup_library; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:130 + def setup_yardopts; end +end + +# source://yard-0.9.28/lib/yard/server/commands/library_command.rb:35 +YARD::Server::Commands::LibraryCommand::CAN_FORK = T.let(T.unsafe(nil), TrueClass) + +# Returns the index of libraries served by the server. +# +# source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:13 +class YARD::Server::Commands::LibraryIndexCommand < ::YARD::Server::Commands::Base + # Returns the value of attribute options. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:14 + def options; end + + # Sets the attribute options + # + # @param value the value to set the attribute options to. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:14 + def options=(_arg0); end + + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:16 + def run; end +end + +# source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:5 +class YARD::Server::Commands::LibraryIndexOptions < ::YARD::CLI::YardocOptions + # Returns the value of attribute adapter. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:6 + def adapter; end + + # Sets the attribute adapter + # + # @param value the value to set the attribute adapter to. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:6 + def adapter=(_arg0); end + + # Returns the value of attribute libraries. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:6 + def libraries; end + + # Sets the attribute libraries + # + # @param value the value to set the attribute libraries to. + # + # source://yard-0.9.28/lib/yard/server/commands/library_index_command.rb:6 + def libraries=(_arg0); end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def serialize; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def serialize=(_arg0); end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def template; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def template=(_arg0); end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def type; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def type=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/server/commands/library_command.rb:7 +class YARD::Server::Commands::LibraryOptions < ::YARD::CLI::YardocOptions + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:8 + def adapter; end + + # Returns the value of attribute command. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:14 + def command; end + + # Sets the attribute command + # + # @param value the value to set the attribute command to. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:14 + def command=(_arg0); end + + # @yield [:adapter, adapter] + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:17 + def each(&block); end + + # Returns the value of attribute frames. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:15 + def frames; end + + # Sets the attribute frames + # + # @param value the value to set the attribute frames to. + # + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:15 + def frames=(_arg0); end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:9 + def library; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:12 + def serialize; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:11 + def serializer; end + + # source://yard-0.9.28/lib/yard/server/commands/library_command.rb:10 + def single_library; end +end + +# Returns a list of objects of a specific type +# +# source://yard-0.9.28/lib/yard/server/commands/list_command.rb:6 +class YARD::Server::Commands::ListCommand < ::YARD::Server::Commands::LibraryCommand + include ::YARD::Templates::Helpers::BaseHelper + + # source://yard-0.9.28/lib/yard/server/commands/list_command.rb:9 + def run; end +end + +# Serves requests from the root of the server +# +# source://yard-0.9.28/lib/yard/server/commands/root_request_command.rb:6 +class YARD::Server::Commands::RootRequestCommand < ::YARD::Server::Commands::Base + include ::WEBrick::HTTPUtils + include ::YARD::Server::Commands::StaticFileHelpers + + # source://yard-0.9.28/lib/yard/server/commands/root_request_command.rb:9 + def run; end +end + +# Performs a search over the objects inside of a library and returns +# the results as HTML or plaintext +# +# source://yard-0.9.28/lib/yard/server/commands/search_command.rb:7 +class YARD::Server::Commands::SearchCommand < ::YARD::Server::Commands::LibraryCommand + include ::YARD::Templates::Helpers::BaseHelper + include ::YARD::Templates::Helpers::ModuleHelper + include ::YARD::Server::DocServerHelper + + # Returns the value of attribute query. + # + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:12 + def query; end + + # Sets the attribute query + # + # @param value the value to set the attribute query to. + # + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:12 + def query=(_arg0); end + + # Returns the value of attribute results. + # + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:12 + def results; end + + # Sets the attribute results + # + # @param value the value to set the attribute results to. + # + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:12 + def results=(_arg0); end + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:14 + def run; end + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:26 + def visible_results; end + + private + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:58 + def search_for_object; end + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:47 + def serve_normal; end + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:37 + def serve_xhr; end + + # source://yard-0.9.28/lib/yard/server/commands/search_command.rb:32 + def url_for(object); end +end + +# Serves static content when no other router matches a request +# +# source://yard-0.9.28/lib/yard/server/commands/static_file_command.rb:6 +class YARD::Server::Commands::StaticFileCommand < ::YARD::Server::Commands::LibraryCommand + include ::WEBrick::HTTPUtils + include ::YARD::Server::Commands::StaticFileHelpers + + # source://yard-0.9.28/lib/yard/server/commands/static_file_command.rb:17 + def run; end +end + +# Defines the paths used to search for static assets. To define an +# extra path, use {YARD::Server.register_static_path} rather than +# modifying this constant directly. Also note that files in the +# document root will always take precedence over these paths. +# +# source://yard-0.9.28/lib/yard/server/commands/static_file_command.rb:15 +YARD::Server::Commands::StaticFileCommand::STATIC_PATHS = T.let(T.unsafe(nil), Array) + +# Include this module to get access to {#static_template_file?} +# and {favicon?} helpers. +# +# source://yard-0.9.28/lib/yard/server/commands/static_file_helpers.rb:9 +module YARD::Server::Commands::StaticFileHelpers + include ::WEBrick::HTTPUtils + + # Serves an empty favicon. + # + # @raise [FinishRequest] finalizes an empty body if the path matches + # /favicon.ico so browsers don't complain. + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/server/commands/static_file_helpers.rb:15 + def favicon?; end + + # Attempts to route a path to a static template file. + # + # @raise [FinishRequest] if a file was found and served + # @return [void] + # + # source://yard-0.9.28/lib/yard/server/commands/static_file_helpers.rb:27 + def static_template_file?; end + + private + + # source://yard-0.9.28/lib/yard/server/commands/static_file_helpers.rb:43 + def find_file(adapter, url); end + + class << self + # source://yard-0.9.28/lib/yard/server/commands/static_file_helpers.rb:43 + def find_file(adapter, url); end + end +end + +# A module that is mixed into {Templates::Template} in order to customize +# certain template methods. +# +# source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:6 +module YARD::Server::DocServerHelper + # @param path_components [Array<String>] components of a URL + # @return [String] the absolute path from any mounted base URI. + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:61 + def abs_url(*path_components); end + + # @example The base path for a library 'foo' + # base_path('docs') # => 'docs/foo' + # @param path [String] the path prefix for a base path URI + # @return [String] the base URI for a library with an extra +path+ prefix + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:69 + def base_path(path); end + + # @return [String] a timestamp for a given file + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:78 + def mtime(file); end + + # @return [String] a URL for a file with a timestamp + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:84 + def mtime_url(file); end + + # @return [Router] convenience method for accessing the router + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:75 + def router; end + + # Modifies {Templates::Helpers::HtmlHelper#url_for} to return a URL instead + # of a disk location. + # + # @param obj [String, CodeObjects::Base] the object (or object path) to link to + # @param anchor [String] the anchor to link to + # @param relative [Boolean] use a relative or absolute link + # @return [String] the URL location of the object + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:11 + def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end + + # Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL instead + # of a disk location. + # + # @param filename [String, CodeObjects::ExtraFileObject] the filename to link to + # @param anchor [String] optional anchor + # @return [String] the URL pointing to the file + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:24 + def url_for_file(filename, anchor = T.unsafe(nil)); end + + # Returns the frames URL for the page + # + # @return [String] the URL pointing to the frames page + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:43 + def url_for_frameset; end + + # Returns the URL for the alphabetic index page + # + # @return [String] the URL pointing to the first main page the + # user should see. + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:55 + def url_for_index; end + + # Modifies {Templates::Helpers::HtmlHelper#url_for_list} to return a URL + # based on the list prefix instead of a HTML filename. + # + # @param type [String, Symbol] the list type to generate a URL for + # @return [String] the URL pointing to the list + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:37 + def url_for_list(type); end + + # Returns the main URL, first checking a readme and then linking to the index + # + # @return [String] the URL pointing to the first main page the + # user should see. + # + # source://yard-0.9.28/lib/yard/server/doc_server_helper.rb:49 + def url_for_main; end +end + +# A custom {Serializers::Base serializer} which returns resource URLs instead of +# static relative paths to files on disk. +# +# source://yard-0.9.28/lib/yard/server/doc_server_serializer.rb:6 +class YARD::Server::DocServerSerializer < ::YARD::Serializers::FileSystemSerializer + # @return [DocServerSerializer] a new instance of DocServerSerializer + # + # source://yard-0.9.28/lib/yard/server/doc_server_serializer.rb:7 + def initialize(_command = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/server/doc_server_serializer.rb:11 + def serialized_path(object); end + + private + + # source://yard-0.9.28/lib/yard/server/doc_server_serializer.rb:31 + def urlencode(name); end +end + +# Short circuits a request by raising an error. This exception is caught +# by {Commands::Base#call} to immediately end a request and return a response. +# +# source://yard-0.9.28/lib/yard/server/adapter.rb:6 +class YARD::Server::FinishRequest < ::RuntimeError; end + +# This exception is raised when {LibraryVersion#prepare!} fails, or discovers +# that the library is not "prepared" to be served by +# +# source://yard-0.9.28/lib/yard/server/library_version.rb:9 +class YARD::Server::LibraryNotPreparedError < ::RuntimeError; end + +# A library version encapsulates a library's documentation at a specific version. +# Although the version is optional, this allows for creating multiple documentation +# points for a specific library, each representing a unique version. The term +# "library" used in other parts of the YARD::Server documentation refers to +# objects of this class unless otherwise noted. +# +# A library points to a location where a {#yardoc_file} is located so that +# its documentation may be loaded and served. Optionally, a {#source_path} is +# given to point to a location where any extra files (and {YARD::CLI::Yardoc .yardopts}) +# should be loaded from. Both of these methods may not be known immediately, +# since the yardoc file may not be built until later. Resolving the yardoc +# file and source path are dependent on the specific library "source type" used. +# Source types (known as "library source") are discussed in detail below. +# +# == Using with Adapters +# A list of libraries need to be passed into adapters upon creation. In +# most cases, you will never do this manually, but if you use a {RackMiddleware}, +# you will need to pass in this list yourself. To build this list of libraries, +# you should create a hash of library names mapped to an *Array* of LibraryVersion +# objects. For example: +# +# {'mylib' => [LibraryVersion.new('mylib', '1.0', ...), +# LibraryVersion.new('mylib', '2.0', ...)]} +# +# Note that you can also use {Adapter#add_library} for convenience. +# +# The "array" part is required, even for just one library version. +# +# == Library Sources +# The {#source} method represents the library source type, ie. where the +# library "comes from". It might come from "disk", or it might come from a +# "gem" (technically the disk, but a separate type nonetheless). In these +# two cases, the yardoc file sits somewhere on your filesystem, though +# it may also be built dynamically if it does not yet exist. This behaviour +# is controlled through the {#prepare!} method, which prepares the yardoc file +# given a specific library source. We will see how this works in detail in +# the following section. +# +# == Implementing a Custom Library Source +# YARD can be extended to support custom library sources in order to +# build or retrieve a yardoc file at runtime from many different locations. +# +# To implement this behaviour, 3 methods can be added to the +LibraryVersion+ +# class, +#load_yardoc_from_SOURCE+, +#yardoc_file_for_SOURCE+, and +# +#source_path_for_SOURCE+. In all cases, "SOURCE" represents the source +# type used in {#source} when creating the library object. The +# +#yardoc_file_for_SOURCE+ and +#source_path_for_SOURCE+ methods are called upon +# creation and should return the location where the source code for the library +# lives. The load method is called from {#prepare!} if there is no yardoc file +# and should set {#yardoc_file}. Below is a full example for +# implementing a custom library source, +:http+, which reads packaged .yardoc +# databases from zipped archives off of an HTTP server. +# +# Note that only +#load_yardoc_from_SOURCE+ is required. The other two +# methods are optional and can be set manually (via {#source_path=} and +# {#yardoc_file=}) on the object at any time. +# +# @example Implementing a Custom Library Source +# # Adds the source type "http" for .yardoc files zipped on HTTP servers +# class LibraryVersion +# def load_yardoc_from_http +# Thread.new do +# # zip/unzip method implementations are not shown +# download_zip_file("http://mysite.com/yardocs/#{self}.zip") +# unzip_file_to("/path/to/yardocs/#{self}") +# end +# +# # tell the server it's not ready yet (but it might be next time) +# raise LibraryNotPreparedError +# end +# +# def yardoc_file_for_http +# "/path/to/yardocs/#{self}/.yardoc" +# end +# +# def source_path_for_http +# File.dirname(yardoc_file) +# end +# end +# +# # Creating a library of this source type: +# LibraryVersion.new('name', '1.0', nil, :http) +# +# source://yard-0.9.28/lib/yard/server/library_version.rb:94 +class YARD::Server::LibraryVersion + # @param name [String] the name of the library + # @param version [String] the specific (usually, but not always, numeric) library + # version + # @param yardoc [String] the location of the yardoc file, or nil if it is + # generated later + # @param source [Symbol] the location of the files used to build the yardoc. + # Builtin source types are +:disk+ or +:gem+. + # @return [LibraryVersion] a new instance of LibraryVersion + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:134 + def initialize(name, version = T.unsafe(nil), yardoc = T.unsafe(nil), source = T.unsafe(nil)); end + + # @return [Boolean] whether another LibraryVersion is equal to this one + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:153 + def ==(other); end + + # @return [Boolean] whether another LibraryVersion is equal to this one + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:153 + def eql?(other); end + + # @return [Boolean] whether another LibraryVersion is equal to this one + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:153 + def equal?(other); end + + # @return [Gem::Specification] a gemspec object for a given library. Used + # for :gem source types. + # @return [nil] if there is no installed gem for the library + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:191 + def gemspec; end + + # @return [Fixnum] used for Hash mapping. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:150 + def hash; end + + # @return [String] the name of the library + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:96 + def name; end + + # @return [String] the name of the library + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:96 + def name=(_arg0); end + + # Prepares a library to be displayed by the server. This callback is + # performed before each request on a library to ensure that it is loaded + # and ready to be viewed. If any steps need to be performed prior to loading, + # they are performed through this method (though they should be implemented + # through the +load_yardoc_from_SOURCE+ method). + # + # @note You should not directly override this method. Instead, implement + # +load_yardoc_from_SOURCENAME+ when implementing loading for a specific + # source type. See the {LibraryVersion} documentation for "Implementing + # a Custom Library Source" + # @raise [LibraryNotPreparedError] if the library is not ready to be + # displayed. Usually when raising this error, you would simultaneously + # begin preparing the library for subsequent requests, although this + # is not necessary. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:182 + def prepare!; end + + # @return [Boolean] whether the library has been completely processed + # and is ready to be served + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:162 + def ready?; end + + # @return [Symbol] the source type representing where the yardoc should be + # loaded from. Defaults are +:disk+ and +:gem+, though custom sources + # may be implemented. This value is used to inform {#prepare!} about how + # to load the necessary data in order to display documentation for an object. + # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source" + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:116 + def source; end + + # @return [Symbol] the source type representing where the yardoc should be + # loaded from. Defaults are +:disk+ and +:gem+, though custom sources + # may be implemented. This value is used to inform {#prepare!} about how + # to load the necessary data in order to display documentation for an object. + # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source" + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:116 + def source=(_arg0); end + + # @return [String] the location of the source code for a library. This + # value is filled by calling +#source_path_for_SOURCE+ on this class. + # @return [nil] if there is no source code + # @see LibraryVersion LibraryVersion documentation for "Implementing a Custom Library Source" + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:122 + def source_path; end + + # Sets the attribute source_path + # + # @param value the value to set the attribute source_path to. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:125 + def source_path=(_arg0); end + + # @param url_format [Boolean] if true, returns the string in a URI-compatible + # format (for appending to a URL). Otherwise, it is given in a more human + # readable format. + # @return [String] the string representation of the library. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:145 + def to_s(url_format = T.unsafe(nil)); end + + # @return [String] the version of the specific library + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:99 + def version; end + + # @return [String] the version of the specific library + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:99 + def version=(_arg0); end + + # @note To implement a custom yardoc file getter, implement + # @return [String] the location of the yardoc file used to load the object + # information from. + # @return [nil] if no yardoc file exists yet. In this case, {#prepare!} will + # be called on this library to build the yardoc file. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:106 + def yardoc_file; end + + # Sets the attribute yardoc_file + # + # @param value the value to set the attribute yardoc_file to. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:109 + def yardoc_file=(_arg0); end + + protected + + # Called when a library of source type "disk" is to be prepared. In this + # case, the {#yardoc_file} should already be set, but the library may not + # be prepared. Run preparation if not done. + # + # @raise [LibraryNotPreparedError] if the yardoc file has not been + # prepared. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:206 + def load_yardoc_from_disk; end + + # Called when a library of source type "gem" is to be prepared. In this + # case, the {#yardoc_file} needs to point to the correct location for + # the installed gem. The yardoc file is built if it has not been done. + # + # @raise [LibraryNotPreparedError] if the gem does not have an existing + # yardoc file. + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:226 + def load_yardoc_from_gem; end + + # @return [String] the source path for a disk source + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:243 + def source_path_for_disk; end + + # @return [String] the source path for a gem source + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:248 + def source_path_for_gem; end + + # @return [String] the yardoc file for a gem source + # + # source://yard-0.9.28/lib/yard/server/library_version.rb:253 + def yardoc_file_for_gem; end + + private + + # source://yard-0.9.28/lib/yard/server/library_version.rb:261 + def load_source_path; end + + # source://yard-0.9.28/lib/yard/server/library_version.rb:266 + def load_yardoc_file; end + + # source://yard-0.9.28/lib/yard/server/library_version.rb:271 + def serializer; end +end + +# Raises an error if a resource is not found. This exception is caught by +# {Commands::Base#call} to immediately end a request and return a 404 response +# code. If a message is provided, the body is set to the exception message. +# +# source://yard-0.9.28/lib/yard/server/adapter.rb:11 +class YARD::Server::NotFoundError < ::RuntimeError; end + +# A router class implements the logic used to recognize a request for a specific +# URL and run specific {Commands::Base commands}. +# +# == Subclassing Notes +# To create a custom router, subclass this class and pass it into the adapter +# options through {Adapter#initialize} or by directly modifying {Adapter#router}. +# +# The most general customization is to change the URL prefixes recognized by +# routing, which can be done by overriding {#docs_prefix}, {#list_prefix}, +# {#static_prefix}, and {#search_prefix}. +# +# == Implementing Custom Caching +# By default, the Router class performs static disk-based caching on all +# requests through the +#check_static_cache+. To override this behaviour, +# or create your own caching mechanism, mixin your own custom module with +# this method implemented as per {StaticCaching#check_static_cache}. +# +# @example Creating a subclassed router +# # Adds 'my' to all routing prefixes +# class MyRouter < YARD::Server::Router +# def docs_prefix; 'mydocs' end +# def list_prefix; 'mylist' end +# def static_prefix; 'mystatic' end +# def search_prefix; 'mysearch' end +# end +# +# # Using it: +# WebrickAdapter.new(libraries, :router => MyRouter).start +# +# source://yard-0.9.28/lib/yard/server/router.rb:32 +class YARD::Server::Router + include ::YARD::Server::StaticCaching + include ::YARD::Server::Commands + + # Creates a new router for a specific adapter + # + # @param adapter [Adapter] the adapter to route requests to + # @return [Router] a new instance of Router + # + # source://yard-0.9.28/lib/yard/server/router.rb:45 + def initialize(adapter); end + + # @return [Adapter] the adapter used by the router + # + # source://yard-0.9.28/lib/yard/server/router.rb:40 + def adapter; end + + # @return [Adapter] the adapter used by the router + # + # source://yard-0.9.28/lib/yard/server/router.rb:40 + def adapter=(_arg0); end + + # Perform routing on a specific request, serving the request as a static + # file through {Commands::RootRequestCommand} if no route is found. + # + # @param request [Adapter Dependent] the request object + # @return [Array(Numeric,Hash,Array)] the Rack-style server response data + # + # source://yard-0.9.28/lib/yard/server/router.rb:54 + def call(request); end + + # @return [String] the URI prefix for all object documentation requests + # + # source://yard-0.9.28/lib/yard/server/router.rb:63 + def docs_prefix; end + + # @return [String] the URI prefix for all class/method/file list requests + # + # source://yard-0.9.28/lib/yard/server/router.rb:66 + def list_prefix; end + + # @return [Array(LibraryVersion, Array<String>)] the library followed + # by the rest of the path components in the request path. LibraryVersion + # will be nil if no matching library was found. + # + # source://yard-0.9.28/lib/yard/server/router.rb:79 + def parse_library_from_path(paths); end + + # @return [Adapter Dependent] the request data coming in with the routing + # + # source://yard-0.9.28/lib/yard/server/router.rb:37 + def request; end + + # @return [Adapter Dependent] the request data coming in with the routing + # + # source://yard-0.9.28/lib/yard/server/router.rb:37 + def request=(_arg0); end + + # @return [String] the URI prefix for all search requests + # + # source://yard-0.9.28/lib/yard/server/router.rb:69 + def search_prefix; end + + # @return [String] the URI prefix for all static assets (templates) + # + # source://yard-0.9.28/lib/yard/server/router.rb:72 + def static_prefix; end + + protected + + # Adds extra :library/:path option keys to the adapter options. + # Use this method when passing options to a command. + # + # @param library [LibraryVersion] the library to route for + # @param paths [Array<String>] path components (split by '/') + # @return [Hash] finalized options + # + # source://yard-0.9.28/lib/yard/server/router.rb:181 + def final_options(library, paths); end + + # Performs routing algorithm to find which prefix is called, first + # parsing out library name/version information. + # + # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response + # @return [nil] if no route is matched + # + # source://yard-0.9.28/lib/yard/server/router.rb:105 + def route(path = T.unsafe(nil)); end + + # Routes requests from {#docs_prefix} and calls the appropriate command + # + # @param library [LibraryVersion] the library to route for + # @param paths [Array<String>] path components (split by '/') + # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response + # @return [nil] if no route is matched + # + # source://yard-0.9.28/lib/yard/server/router.rb:128 + def route_docs(library, paths); end + + # Routes for the index of a library / multiple libraries + # + # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response + # @return [nil] if no route is matched + # + # source://yard-0.9.28/lib/yard/server/router.rb:146 + def route_index; end + + # Routes requests from {#list_prefix} and calls the appropriate command + # + # @param library [LibraryVersion] the library to route for + # @param paths [Array<String>] path components (split by '/') + # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response + # @return [nil] if no route is matched + # + # source://yard-0.9.28/lib/yard/server/router.rb:157 + def route_list(library, paths); end + + # Routes requests from {#search_prefix} and calls the appropriate command + # + # @param library [LibraryVersion] the library to route for + # @param paths [Array<String>] path components (split by '/') + # @return [Array(Numeric,Hash,Array<String>)] the Rack-style response + # @return [nil] if no route is matched + # + # source://yard-0.9.28/lib/yard/server/router.rb:165 + def route_search(library, paths); end + + # source://yard-0.9.28/lib/yard/server/router.rb:170 + def route_static(library, paths); end +end + +# Implements static caching for requests. +# +# @see Router Router documentation for "Caching" +# +# source://yard-0.9.28/lib/yard/server/static_caching.rb:7 +module YARD::Server::StaticCaching + # Called by a router to return the cached object. By default, this + # method performs disk-based caching. To perform other forms of caching, + # implement your own +#check_static_cache+ method and mix the module into + # the Router class. + # + # Note that caching does not occur here. This method simply checks for + # the existence of cached data. To actually cache a response, see + # {Commands::Base#cache}. + # + # @example Implementing In-Memory Cache Checking + # module MemoryCaching + # def check_static_cache + # # $memory_cache is filled by {Commands::Base#cache} + # cached_data = $memory_cache[request.path] + # if cached_data + # [200, {'Content-Type' => 'text/html'}, [cached_data]] + # else + # nil + # end + # end + # end + # + # class YARD::Server::Router; include MemoryCaching; end + # @return [Array(Numeric,Hash,Array)] the Rack-style response + # @return [nil] if no cache is available and routing should continue + # @see Commands::Base#cache + # + # source://yard-0.9.28/lib/yard/server/static_caching.rb:34 + def check_static_cache; end +end + +# The main adapter to initialize a WEBrick server. +# +# source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:9 +class YARD::Server::WebrickAdapter < ::YARD::Server::Adapter + # Initializes a WEBrick server. If {Adapter#server_options} contains a + # +:daemonize+ key set to true, the server will be daemonized. + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:10 + def start; end +end + +# The main WEBrick servlet implementation, accepting only GET requests. +# +# source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:20 +class YARD::Server::WebrickServlet < ::WEBrick::HTTPServlet::AbstractServlet + # @return [WebrickServlet] a new instance of WebrickServlet + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:23 + def initialize(server, adapter); end + + # Returns the value of attribute adapter. + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:21 + def adapter; end + + # Sets the attribute adapter + # + # @param value the value to set the attribute adapter to. + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:21 + def adapter=(_arg0); end + + # @private + # + # source://yard-0.9.28/lib/yard/server/webrick_adapter.rb:29 + def do_GET(request, response); end +end + +# Stubs marshal dumps and acts a delegate class for an object by path +# +# @private +# +# source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:6 +class YARD::StubProxy + # @return [StubProxy] a new instance of StubProxy + # + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:13 + def initialize(path, transient = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:9 + def _dump(_depth); end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:11 + def hash; end + + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:18 + def method_missing(meth, *args, &block); end + + class << self + # source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:10 + def _load(str); end + end +end + +# source://yard-0.9.28/lib/yard/serializers/yardoc_serializer.rb:28 +YARD::StubProxy::FILELEN = T.let(T.unsafe(nil), Integer) + +# The root path for YARD builtin templates +# +# source://yard-0.9.28/lib/yard.rb:10 +YARD::TEMPLATE_ROOT = T.let(T.unsafe(nil), String) + +# Namespace for Tag components +# +# source://yard-0.9.28/lib/yard/autoload.rb:247 +module YARD::Tags; end + +# Defines an attribute with a given name, using indented block data as the +# attribute's docstring. If the type specifier is supplied with "r", "w", or +# "rw", the attribute is made readonly, writeonly or readwrite respectively. +# A readwrite attribute is the default, if no type is specified. The comment +# containing this directive does not need to be attached to any source, but +# if it is, that source code will be used as the method's source. +# +# To define a regular method, see {tag:!method} +# +# @example Defining a simple readonly attribute +# # @!attribute [r] count +# # @return [Fixnum] the size of the list +# @example Defining a simple readwrite attribute +# # @!attribute name +# # @return [String] the name of the user +# @note This directive should only be used if there is no explicit +attr_*+ +# declaration for the attribute in any source files (i.e., the attribute +# is declared dynamically via meta-programming). In all other cases, add +# documentation to the attribute declaration itself. +# @note For backwards compatibility support, you do not need to indent +# the attribute's docstring text. If an +@!attribute+ directive is seen with +# no indented block, the entire docstring is used as the new attribute's +# docstring text. +# @see tag:!method +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:461 +class YARD::Tags::AttributeDirective < ::YARD::Tags::MethodDirective + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:462 + def after_parse; end + + protected + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:470 + def method_name; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:476 + def method_signature; end + + private + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:486 + def create_attribute_data(object); end + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:516 + def readable?; end + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:512 + def writable?; end +end + +# source://yard-0.9.28/lib/yard/tags/default_factory.rb:4 +class YARD::Tags::DefaultFactory + # Parses tag text and creates a new tag with descriptive text + # + # @param tag_name the name of the tag to parse + # @param text [String] the raw tag text + # @return [Tag] a tag object with the tag_name and text values filled + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:13 + def parse_tag(tag_name, text); end + + # Parses tag text and creates a new tag with a key name and descriptive text + # + # @param tag_name the name of the tag to parse + # @param text [String] the raw tag text + # @return [Tag] a tag object with the tag_name, name and text values filled + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:22 + def parse_tag_with_name(tag_name, text); end + + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:89 + def parse_tag_with_options(tag_name, text); end + + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:70 + def parse_tag_with_title_and_text(tag_name, text); end + + # Parses tag text and creates a new tag with formally declared types and + # descriptive text + # + # @param tag_name the name of the tag to parse + # @param text [String] the raw tag text + # @raise [TagFormatError] + # @return [Tag] a tag object with the tag_name, types and text values filled + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:33 + def parse_tag_with_types(tag_name, text); end + + # Parses tag text and creates a new tag with formally declared types, a key + # name and descriptive text + # + # @param tag_name the name of the tag to parse + # @param text [String] the raw tag text + # @return [Tag] a tag object with the tag_name, name, types and text values filled + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:45 + def parse_tag_with_types_and_name(tag_name, text); end + + # Parses tag text and creates a new tag with formally declared types, a title + # on the first line and descriptive text + # + # @param tag_name the name of the tag to parse + # @param text [String] the raw tag text + # @return [Tag] a tag object with the tag_name, name, types and text values filled + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:57 + def parse_tag_with_types_and_title(tag_name, text); end + + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:75 + def parse_tag_with_types_name_and_default(tag_name, text); end + + private + + # Extracts the name from raw tag text returning the name and remaining value + # + # @param text [String] the raw tag text + # @return [Array] an array holding the name as the first element and the + # value as the second element + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:101 + def extract_name_from_text(text); end + + # @raise [TagFormatError] + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:105 + def extract_title_and_desc_from_text(text); end + + # Parses a [], <>, {} or () block at the beginning of a line of text + # into a list of comma delimited values. + # + # @example + # obj.parse_types('[String, Array<Hash, String>, nil]') # => [nil, ['String', 'Array<Hash, String>', 'nil'], ""] + # obj.parse_types('b<String> A string') # => ['b', ['String'], 'A string'] + # @return [Array(String, Array<String>, String)] the text before the type + # list (or nil), followed by the type list parsed into an array of + # strings, followed by the text following the type list. + # + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:129 + def extract_types_and_name_from_text(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/tags/default_factory.rb:138 + def extract_types_and_name_from_text_unstripped(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end +end + +# source://yard-0.9.28/lib/yard/tags/default_factory.rb:6 +YARD::Tags::DefaultFactory::TYPELIST_CLOSING_CHARS = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/tags/default_factory.rb:5 +YARD::Tags::DefaultFactory::TYPELIST_OPENING_CHARS = T.let(T.unsafe(nil), String) + +# source://yard-0.9.28/lib/yard/tags/default_tag.rb:4 +class YARD::Tags::DefaultTag < ::YARD::Tags::Tag + # @return [DefaultTag] a new instance of DefaultTag + # + # source://yard-0.9.28/lib/yard/tags/default_tag.rb:7 + def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil), defaults = T.unsafe(nil)); end + + # Returns the value of attribute defaults. + # + # source://yard-0.9.28/lib/yard/tags/default_tag.rb:5 + def defaults; end +end + +# The base directive class. Subclass this class to create a custom +# directive, registering it with {Library.define_directive}. Directive +# classes are executed via the {#call} method, which perform all directive +# processing on the object. +# +# If processing occurs within a handler, the {#handler} attribute is +# available to access more information about parsing context and state. +# Handlers are only available when parsing from {Parser::SourceParser}, +# not when parsing directly from {DocstringParser}. If the docstring is +# attached to an object declaration, {#object} will be set and available +# to modify the generated code object directly. Note that both of these +# attributes may be nil, and directives should test their existence +# before attempting to use them. +# +# @abstract Subclasses should implement {#call}. +# @see Library.define_directive +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:23 +class YARD::Tags::Directive + # @param tag [Tag] the meta-data tag containing all input to the docstring + # @param parser [DocstringParser] the docstring parser object + # @return [Directive] a new instance of Directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:55 + def initialize(tag, parser); end + + # Called after parsing all directives and tags in the docstring. Used + # to perform any cleanup after all directives perform their main task. + # + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:74 + def after_parse; end + + # Called when processing the directive. Subclasses should implement + # this method to perform all functionality of the directive. + # + # @abstract implement this method to perform all data processing for + # the directive. + # @raise [NotImplementedError] + # @return [void] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:69 + def call; end + + # Set this field to replace the directive definition inside of a docstring + # with arbitrary text. For instance, the {MacroDirective} uses this field + # to expand its macro data in place of the call to a +@!macro+. + # + # @return [String] the text to expand in the original docstring in place + # of this directive definition. + # @return [nil] if no expansion should take place for this directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:34 + def expanded_text; end + + # Set this field to replace the directive definition inside of a docstring + # with arbitrary text. For instance, the {MacroDirective} uses this field + # to expand its macro data in place of the call to a +@!macro+. + # + # @return [String] the text to expand in the original docstring in place + # of this directive definition. + # @return [nil] if no expansion should take place for this directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:34 + def expanded_text=(_arg0); end + + # @return [Handlers::Base, nil] the handler object the docstring parser + # might be attached to. May be nil. Only available when parsing + # through {Parser::SourceParser}. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:49 + def handler; end + + # @return [CodeObjects::Base, nil] the object the parent docstring is + # attached to. May be nil. + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:43 + def object; end + + # @return [DocstringParser] the parser that is parsing all tag + # information out of the docstring + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:38 + def parser=(_arg0); end + + # @return [Tag] the meta-data tag containing data input to the directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:25 + def tag; end + + # @return [Tag] the meta-data tag containing data input to the directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:25 + def tag=(_arg0); end + + protected + + # @return [Boolean] + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:80 + def inside_directive?; end + + # @return [DocstringParser] the parser that is parsing all tag + # information out of the docstring + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:38 + def parser; end +end + +# Ends a group listing definition. Group definition automatically end +# when class or module blocks are closed, and defining a new group overrides +# the last group definition, but occasionally you need to end the current +# group to return to the default listing. Use {tag:!group} to begin a +# group listing. +# +# @example +# class Controller +# # @!group Callbacks +# +# def before_filter; end +# def after_filter; end +# +# # @!endgroup +# +# def index; end +# end +# @see tag:!group +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:105 +class YARD::Tags::EndGroupDirective < ::YARD::Tags::Directive + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:106 + def call; end +end + +# Defines a group listing. All methods (and attributes) seen after this +# directive are placed into a group with the given description as the +# group name. The group listing is used by templates to organize methods +# and attributes into respective logical groups. To end a group listing +# use {tag:!endgroup}. +# +# @example +# # @!group Callbacks +# +# def before_filter; end +# def after_filter; end +# @note A group definition only applies to the scope it is defined in. +# If a new class or module is opened after the directive, this directive +# will not apply to methods in that class or module. +# @see tag:!endgroup +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:128 +class YARD::Tags::GroupDirective < ::YARD::Tags::Directive + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:129 + def call; end +end + +# Keeps track of all the registered meta-data tags and directives. +# Also allows for defining of custom tags and customizing the tag parsing +# syntax. +# +# == Defining Custom Meta-Data Tags +# +# To define a custom tag, use {define_tag}. You should pass the tag +# name and the factory method to use when creating the tag. If you do not +# provide a factory method to use, it will default to {DefaultFactory#parse_tag} +# +# You can also define tag objects manually by simply implementing a "tagname_tag" +# method that returns a {Tag} object, but they will not take advantage of tag factory +# parsing: +# +# def mytag_tag(text) +# Tag.new(:mytag, text) +# end +# +# == Defining Custom Directives +# +# Directives can be defined by calling the {define_directive} method, taking +# the directive name, an optional tag factory parser method (to parse the +# data in the directive into a temporary {Tag} object) and a {Directive} subclass +# that performs the directive processing. For more information on creating a +# Directive subclass, see the {Directive} class documentation. +# +# Similar to tags, Directives can also be defined manually, in this case using +# the method name "mydirective_directive" and returning a new {Directive} object: +# +# def mydirective_directive(tag, parser) +# MyDirective.new(tag, parser) +# end +# +# == Namespaced Tags +# +# In YARD 0.8.0+, tags can be namespaced using the '.' character. It is recommended +# to namespace project specific tags, like +@yard.tag_name+, so that tags do not +# collide with other plugins or new built-in tags. +# +# == Adding/Changing the Tag Syntax +# +# If you have specialized tag parsing needs you can substitute the {#factory} +# object with your own by setting {Library.default_factory= Library.default_factory} +# to a new class with its own parsing methods before running YARD. This is useful +# if you want to change the syntax of existing tags (@see, @since, etc.) +# +# @example Defining a custom tag +# define_tag "Parameter", :param, :with_types_and_name +# define_tag "Author", :author +# @example Defining a custom directive +# define_directive :method, :with_title_and_text, MethodDirective +# @see DefaultFactory +# @see define_tag +# @see define_directive +# @see Directive +# +# source://yard-0.9.28/lib/yard/tags/library.rb:59 +class YARD::Tags::Library + # @return [Library] a new instance of Library + # + # source://yard-0.9.28/lib/yard/tags/library.rb:260 + def initialize(factory = T.unsafe(nil)); end + + # Marks a class/module/method as abstract with optional + # implementor information. + # + # @example + # # @abstract Subclass and override {#run} to implement + # # a custom Threadable class. + # class Runnable + # def run; raise NotImplementedError end + # end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def abstract_tag(text); end + + # Declares the API that the object belongs to. Does not display in + # output, but useful for performing queries (+yardoc --query+). Any text is + # allowable in this tag, and there are no predefined values. + # + # @example + # class Post + # # @api private + # def reset_table!; table.flush end + # end + # @note This tag is *transitive*. If it is applied on a + # namespace (module or class), it will immediately be + # applied to all children objects of that namespace unless + # it is redefined on the child object. + # @note The special name +@api private+ does display a notice in + # documentation if it is listed, letting users know that the + # method is not to be used by external components. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def api_tag(text); end + + # Declares a readonly attribute on a Struct or class. + # + # @deprecated Use the more powerful {tag:!attribute} directive instead. + # @example + # # @attr_reader [String] name the name of the structure + # # @attr_reader [Fixnum] size the size of the structure + # class MyStruct < Struct; end + # @note This attribute is only applicable on class docstrings + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def attr_reader_tag(text); end + + # Declares a readwrite attribute on a Struct or class. + # + # @deprecated Use the more powerful {tag:!attribute} directive instead. + # @example + # # @attr [String] name the name of the structure + # # @attr [Fixnum] size the size of the structure + # class MyStruct < Struct; end + # @note This attribute is only applicable on class docstrings + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def attr_tag(text); end + + # Declares a writeonly attribute on a Struct or class. + # + # @deprecated Use the more powerful {tag:!attribute} directive instead. + # @example + # # @attr_reader [String] name the name of the structure + # # @attr_reader [Fixnum] size the size of the structure + # class MyStruct < Struct; end + # @note This attribute is only applicable on class docstrings + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def attr_writer_tag(text); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def attribute_directive(tag, parser); end + + # List the author or authors of a class, module, or method. + # + # @example + # # @author Foo Bar <foo@bar.com> + # class MyClass; end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def author_tag(text); end + + # Marks a method/class as deprecated with an optional description. + # The description should be used to inform users of the recommended + # migration path, and/or any useful information about why the object + # was marked as deprecated. + # + # @example Deprecate a method with a replacement API + # # @deprecated Use {#bar} instead. + # def foo; end + # @example Deprecate a method with no replacement + # class Thread + # # @deprecated Exiting a thread in this way is not reliable and + # # can cause a program crash. + # def kill; end + # end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def deprecated_tag(text); end + + # Creates a new directive with tag information and a docstring parser + # object. + # + # @param tag_name [String] the name of the tag + # @param tag_buf [String] the tag data + # @param parser [DocstringParser] the parser object parsing the docstring + # @return [Directive] the newly created directive + # + # source://yard-0.9.28/lib/yard/tags/library.rb:290 + def directive_create(tag_name, tag_buf, parser); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def endgroup_directive(tag, parser); end + + # Show an example snippet of code for an object. The first line + # is an optional title. + # + # @example + # # @example Reverse a String + # # "mystring".reverse #=> "gnirtsym" + # def reverse; end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def example_tag(text); end + + # A factory class to handle parsing of tags, defaults to {default_factory} + # + # source://yard-0.9.28/lib/yard/tags/library.rb:258 + def factory; end + + # A factory class to handle parsing of tags, defaults to {default_factory} + # + # source://yard-0.9.28/lib/yard/tags/library.rb:258 + def factory=(_arg0); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def group_directive(tag, parser); end + + # @param tag_name [#to_s] the name of the tag to look for + # @return [Boolean] whether a directive by the given name is registered in + # the library. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:280 + def has_directive?(tag_name); end + + # @param tag_name [#to_s] the name of the tag to look for + # @return [Boolean] whether a tag by the given name is registered in + # the library. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:267 + def has_tag?(tag_name); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def macro_directive(tag, parser); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def method_directive(tag, parser); end + + # Adds an emphasized note at the top of the docstring for the object + # + # @example + # # @note This method should only be used in outer space. + # def eject; end + # @see tag:todo + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def note_tag(text); end + + # Describe an options hash in a method. The tag takes the + # name of the options parameter first, followed by optional types, + # the option key name, a default value for the key and a + # description of the option. The default value should be placed within + # parentheses and is optional (can be omitted). + # + # Note that a +@param+ tag need not be defined for the options + # hash itself, though it is useful to do so for completeness. + # + # @example + # # @param [Hash] opts the options to create a message with. + # # @option opts [String] :subject The subject + # # @option opts [String] :from ('nobody') From address + # # @option opts [String] :to Recipient email + # # @option opts [String] :body ('') The email's body + # def send_email(opts = {}) end + # @note For keyword parameters, use +@param+, not +@option+. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def option_tag(text); end + + # Describe that your method can be used in various + # contexts with various parameters or return types. The first + # line should declare the new method signature, and the following + # indented tag data will be a new documentation string with its + # own tags adding metadata for such an overload. + # + # @example + # # @overload set(key, value) + # # Sets a value on key + # # @param key [Symbol] describe key param + # # @param value [Object] describe value param + # # @overload set(value) + # # Sets a value on the default key +:foo+ + # # @param value [Object] describe value param + # def set(*args) end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:161 + def overload_tag(text); end + + # Documents a single method parameter (either regular or keyword) with a given name, type + # and optional description. + # + # @example + # # @param url [String] the URL of the page to download + # # @param directory [String] the name of the directory to save to + # def load_page(url, directory: 'pages') end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def param_tag(text); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def parse_directive(tag, parser); end + + # Declares that the _logical_ visibility of an object is private. + # In other words, it specifies that this method should be marked + # private but cannot due to Ruby's visibility restrictions. This + # exists for classes, modules and constants that do not obey Ruby's + # visibility rules. For instance, an inner class might be considered + # "private", though Ruby would make no such distinction. + # + # This tag is meant to be used in conjunction with the +--no-private+ + # command-line option, and is required to actually remove these objects + # from documentation output. See {file:README.md} for more information on + # switches. + # + # If you simply want to set the API visibility of a method, you should + # look at the {tag:api} tag instead. + # + # @example + # # @private + # class InteralImplementation; end + # @note This method is not recommended for hiding undocumented or + # "unimportant" methods. This tag should only be used to mark objects + # private when Ruby visibility rules cannot do so. In Ruby 1.9.3, you + # can use +private_constant+ to declare constants (like classes or + # modules) as private, and should be used instead of +@private+. + # @note This tag is *transitive*. If it is applied on a + # namespace (module or class), it will immediately be + # applied to all children objects of that namespace unless + # it is redefined on the child object. + # @see tag:api + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def private_tag(text); end + + # Describes that a method may raise a given exception, with + # an optional description of what it may mean. + # + # @example + # # @raise [AccountBalanceError] if the account does not have + # # sufficient funds to perform the transaction + # def withdraw(amount) end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def raise_tag(text); end + + # Describes the return value (and type or types) of a method. + # You can list multiple return tags for a method in the case + # where a method has distinct return cases. In this case, each + # case should begin with "if ...". + # + # @example A regular return value + # # @return [Fixnum] the size of the file + # def size; @file.size end + # @example A method returns an Array or a single object + # # @return [String] if a single object was returned + # # from the database. + # # @return [Array<String>] if multiple objects were + # # returned. + # def find(query) end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def return_tag(text); end + + # Sets the scope of a DSL method. Only applicable to DSL method + # calls. Acceptable values are 'class' or 'instance' + # + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def scope_directive(tag, parser); end + + # "See Also" references for an object. Accepts URLs or + # other code objects with an optional description at the end. + # Note that the URL or object will be automatically linked by + # YARD and does not need to be formatted with markup. + # + # @example + # # Synchronizes system time using NTP. + # # @see http://ntp.org/documentation.html NTP Documentation + # # @see NTPHelperMethods + # class NTPUpdater; end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def see_tag(text); end + + # Lists the version that the object was first added. + # + # @example + # # @since 1.2.4 + # def clear_routes; end + # @note This tag is *transitive*. If it is applied on a + # namespace (module or class), it will immediately be + # applied to all children objects of that namespace unless + # it is redefined on the child object. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def since_tag(text); end + + # Creates a new {Tag} object with a given tag name and data + # + # @return [Tag] the newly created tag object + # + # source://yard-0.9.28/lib/yard/tags/library.rb:273 + def tag_create(tag_name, tag_buf); end + + # Marks a TODO note in the object being documented. + # For reference, objects with TODO items can be enumerated + # from the command line with a simple command: + # + # !!!sh + # mocker$ yard list --query '@todo' + # lib/mocker/mocker.rb:15: Mocker + # lib/mocker/report/html.rb:5: Mocker::Report::Html + # + # YARD can also be used to enumerate the TODO items from + # a short script: + # + # !!!ruby + # require 'yard' + # YARD::Registry.load!.all.each do |o| + # puts o.tag(:todo).text if o.tag(:todo) + # end + # + # @example + # # @todo Add support for Jabberwocky service. + # # There is an open source Jabberwocky library available + # # at http://jbrwcky.org that can be easily integrated. + # class Wonderlander; end + # @see tag:note + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def todo_tag(text); end + + # Lists the version of a class, module or method. This is + # similar to a library version, but at finer granularity. + # In some cases, version of specific modules, classes, methods + # or generalized components might change independently between + # releases. A version tag is used to infer the API compatibility + # of a specific object. + # + # @example + # # The public REST API for http://jbrwcky.org + # # @version 2.0 + # class JabberwockyAPI; end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def version_tag(text); end + + # Sets the visibility of a DSL method. Only applicable to + # DSL method calls. Acceptable values are public, protected, or private. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:202 + def visibility_directive(tag, parser); end + + # Describes what a method might yield to a given block. + # The types specifier list should not list types, but names + # of the parameters yielded to the block. If you define + # parameters with +@yieldparam+, you do not need to define + # the parameters in the type specification of +@yield+ as + # well. + # + # @example + # # For a block {|a,b,c| ... } + # # @yield [a, b, c] Gives 3 random numbers to the block + # def provide3values(&block) yield(42, 42, 42) end + # @see tag:yieldparam + # @see tag:yieldreturn + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def yield_tag(text); end + + # Defines a parameter yielded by a block. If you define the + # parameters with +@yieldparam+, you do not need to define + # them via +@yield+ as well. + # + # @example + # # @yieldparam [String] name the name that is yielded + # def with_name(name) yield(name) end + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def yieldparam_tag(text); end + + # Documents the value and type that the block is expected + # to return to the method. + # + # @example + # # @yieldreturn [Fixnum] the number to add 5 to. + # def add5_block(&block) 5 + yield end + # @see tag:return + # + # source://yard-0.9.28/lib/yard/tags/library.rb:168 + def yieldreturn_tag(text); end + + private + + # @return [Directive] + # + # source://yard-0.9.28/lib/yard/tags/library.rb:244 + def directive_call(tag, parser); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:233 + def send_to_factory(tag_name, meth, text); end + + class << self + # Replace the factory object responsible for parsing tags by setting + # this to an object (or class) that responds to +parse_TAGNAME+ methods + # where +TAGNAME+ is the name of the tag. + # + # You should set this value before performing any source parsing with + # YARD, otherwise your factory class will not be used. + # + # @example + # YARD::Tags::Library.default_factory = MyFactory + # @see DefaultFactory + # + # source://yard-0.9.28/lib/yard/tags/library.rb:83 + def default_factory; end + + # Replace the factory object responsible for parsing tags by setting + # this to an object (or class) that responds to +parse_TAGNAME+ methods + # where +TAGNAME+ is the name of the tag. + # + # You should set this value before performing any source parsing with + # YARD, otherwise your factory class will not be used. + # + # @example + # YARD::Tags::Library.default_factory = MyFactory + # @see DefaultFactory + # + # source://yard-0.9.28/lib/yard/tags/library.rb:87 + def default_factory=(factory); end + + # @overload define_directive + # + # source://yard-0.9.28/lib/yard/tags/library.rb:196 + def define_directive(tag, tag_meth = T.unsafe(nil), directive_class = T.unsafe(nil)); end + + # Convenience method to define a new tag using one of {Tag}'s factory methods, or the + # regular {DefaultFactory#parse_tag} factory method if none is supplied. + # + # @param label [#to_s] the label used when displaying the tag in templates + # @param tag [#to_s] the tag name to create + # @param meth [#to_s, Class<Tag>] the {Tag} factory method to call when + # creating the tag or the name of the class to directly create a tag for + # + # source://yard-0.9.28/lib/yard/tags/library.rb:157 + def define_tag(label, tag, meth = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/tags/library.rb:220 + def directive_method_name(tag_name); end + + # Returns the factory method used to parse the tag text for a specific tag + # + # @param tag [Symbol] the tag name + # @return [Symbol] the factory method name for the tag + # @return [Class<Tag>, Symbol] the Tag class to use to parse the tag + # or the method to call on the factory class + # @return [nil] if the tag is freeform text + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:99 + def factory_method_for(tag); end + + # Returns the factory method used to parse the tag text for a specific + # directive + # + # @param directive [Symbol] the directive name + # @return [Symbol] the factory method name for the tag + # @return [Class<Tag>, Symbol] the Tag class to use to parse the tag or + # the methods to call on the factory class + # @return [nil] if the tag is freeform text + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:112 + def factory_method_for_directive(directive); end + + # @return [Library] the main Library instance object. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:67 + def instance; end + + # @return [SymbolHash{Symbol=>String}] the map of tag names and their + # respective display labels. + # + # source://yard-0.9.28/lib/yard/tags/library.rb:63 + def labels; end + + # Sorts the labels lexically by their label name, often used when displaying + # the tags. + # + # @return [Array<Symbol>, String] the sorted labels as an array of the tag name and label + # + # source://yard-0.9.28/lib/yard/tags/library.rb:142 + def sorted_labels; end + + # source://yard-0.9.28/lib/yard/tags/library.rb:216 + def tag_method_name(tag_name); end + + # Sets the list of tags that should apply to any children inside the + # namespace they are defined in. For instance, a "@since" tag should + # apply to all methods inside a module it is defined in. Transitive + # tags can be overridden by directly defining a tag on the child object. + # + # @return [Array<Symbol>] a list of transitive tags + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:136 + def transitive_tags; end + + # Sets the list of tags that should apply to any children inside the + # namespace they are defined in. For instance, a "@since" tag should + # apply to all methods inside a module it is defined in. Transitive + # tags can be overridden by directly defining a tag on the child object. + # + # @return [Array<Symbol>] a list of transitive tags + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:136 + def transitive_tags=(_arg0); end + + # Sets the list of tags to display when rendering templates. The order of + # tags in the list is also significant, as it represents the order that + # tags are displayed in templates. + # + # You can use the {Array#place} to insert new tags to be displayed in + # the templates at specific positions: + # + # Library.visible_tags.place(:mytag).before(:return) + # + # @return [Array<Symbol>] a list of ordered tags + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:127 + def visible_tags; end + + # Sets the list of tags to display when rendering templates. The order of + # tags in the list is also significant, as it represents the order that + # tags are displayed in templates. + # + # You can use the {Array#place} to insert new tags to be displayed in + # the templates at specific positions: + # + # Library.visible_tags.place(:mytag).before(:return) + # + # @return [Array<Symbol>] a list of ordered tags + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/tags/library.rb:127 + def visible_tags=(_arg0); end + + private + + # source://yard-0.9.28/lib/yard/tags/library.rb:226 + def tag_or_directive_method_name(tag_name, type = T.unsafe(nil)); end + end +end + +# Defines a block of text to be expanded whenever the macro is called by name +# in subsequent docstrings. The macro data can be any arbitrary text data, be +# it regular documentation, meta-data tags or directives. +# +# == Defining a Macro +# +# A macro must first be defined in order to be used. Note that a macro is also +# expanded upon definition if it defined on an object (the docstring of a +# method, class, module or constant object as opposed to a free standing +# comment). To define a macro, use the "new" or "attach" identifier in the +# types specifier list. A macro will also automatically be created if an +# indented macro data block is given, so the keywords are not strictly needed. +# +# === Anonymous Macros +# +# In addition to standard named macros, macros can be defined anonymously if +# no name is given. In this case, they can not be re-used in future docstrings, +# but they will expand in the first definition. This is useful when needing +# to take advantage of the macro expansion variables (described below). +# +# == Using a Macro +# +# To re-use a macro in another docstring after it is defined, simply use +# <tt>@!macro the_name</tt> with no indented block of macro data. The resulting +# data will be expanded in place. +# +# == Attaching a Macro to a DSL Method +# +# Macros can be defined to auto-expand on DSL-style class method calls. To +# define a macro to be auto expanded in this way, use the "attach" keyword +# in the type specifier list ("new" is implied). +# +# Attached macros can also be attached directly on the class method declaration +# that provides the DSL method to its subclasses. The syntax in either case +# is the same. +# +# == Macro Expansion Variables +# +# In the case of using macros on DSL-style method calls, a number of expansion +# variables can be used for interpolation inside of the macro data. The variables, +# similar in syntax to Ruby's global variables, are as follows: +# +# * $0 - the method name being called +# * $1, $2, $3, ... - the Nth argument in the method call +# * $& - the full source line +# +# The following example shows what the expansion variables might hold for a given +# DSL method call: +# +# property :foo, :a, :b, :c, String +# # $0 => "property" +# # $1 => "foo" +# # $2 => "a" +# # $& => "property :foo, :a, :b, :c, String" +# +# === Ranges +# +# Ranges are also acceptable with the syntax <tt>${N-M}</tt>. Negative values +# on either N or M are valid, and refer to indexes from the end of the list. +# Consider a DSL method that creates a method using the first argument with +# argument names following, ending with the return type of the method. This +# could be documented as: +# +# # @!macro dsl_method +# # @!method $1(${2--2}) +# # @return [${-1}] the return value of $0 +# create_method_with_args :foo, :a, :b, :c, String +# +# As described, the method is using the signature <tt>foo(a, b, c)</tt> and the return +# type from the last argument, +String+. When using ranges, tokens are joined +# with commas. Note that this includes using $0: +# +# !!!plain +# $0-1 # => Interpolates to "create_method_with_args, foo" +# +# If you want to separate them with spaces, use <tt>$1 $2 $3 $4 ...</tt>. Note that +# if the token cannot be expanded, it will return the empty string (not an error), +# so it would be safe to list <tt>$1 $2 ... $10</tt>, for example. +# +# === Escaping Interpolation +# +# Interpolation can be escaped by prefixing the +$+ with +\\\+, like so: +# +# # @!macro foo +# # I have \$2.00 USD. +# +# @example Defining a simple macro +# # @!macro [new] returnself +# # @return [self] returns itself +# @example Using a simple macro in multiple docstrings +# # Documentation for map +# # ... +# # @macro returnself +# def map; end +# +# # Documentation for filter +# # ... +# # @macro returnself +# def filter; end +# @example Attaching a macro to a class method (for DSL usage) +# class Resource +# # Defines a new property +# # @param [String] name the property name +# # @param [Class] type the property's type +# # @!macro [attach] property +# # @return [$2] the $1 property +# def self.property(name, type) end +# end +# +# class Post < Resource +# property :title, String +# property :view_count, Integer +# end +# @example Attaching a macro directly to a DSL method +# class Post < Resource +# # @!macro [attach] property +# # @return [$2] the $1 property +# property :title, String +# +# # Macro will expand on this definition too +# property :view_count, Integer +# end +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:258 +class YARD::Tags::MacroDirective < ::YARD::Tags::Directive + # @raise [TagFormatError] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:259 + def call; end + + private + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:288 + def anonymous?; end + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:277 + def attach?; end + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:283 + def class_method?; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:292 + def expand(macro_data); end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:308 + def find_or_create; end + + # @return [Boolean] + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:272 + def new?; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:332 + def warn; end +end + +# Defines a method object with a given method signature, using indented +# block data as the method's docstring. The signature is similar to the +# {tag:overload} tag. The comment containing this directive does not need +# to be attached to any source, but if it is, that source code will be +# used as the method's source. +# +# To define an attribute method, see {tag:!attribute} +# +# @example Defining a simple method +# # @!method quit(username, message = "Quit") +# # Sends a quit message to the server for a +username+. +# # @param [String] username the username to quit +# # @param [String] message the quit message +# quit_message_method +# @example Attaching multiple methods to the same source +# # @!method method1 +# # @!method method2 +# create_methods :method1, :method2 +# @note This directive should only be used if there is no explicit +# declaration for the method in any source files (i.e., the method +# is declared dynamically via meta-programming). In all other cases, add +# documentation to the method definition itself. +# @note For backwards compatibility support, you do not need to indent +# the method's docstring text. If a +@!method+ directive is seen with +# no indented block, the entire docstring is used as the new method's +# docstring text. +# @see tag:!attribute +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:368 +class YARD::Tags::MethodDirective < ::YARD::Tags::Directive + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:373 + def after_parse; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:371 + def call; end + + protected + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:413 + def create_object; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:381 + def method_name; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:390 + def method_signature; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:394 + def sanitized_tag_signature; end + + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:403 + def use_indented_text; end +end + +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:369 +YARD::Tags::MethodDirective::SCOPE_MATCH = T.let(T.unsafe(nil), Regexp) + +# source://yard-0.9.28/lib/yard/tags/option_tag.rb:4 +class YARD::Tags::OptionTag < ::YARD::Tags::Tag + # @return [OptionTag] a new instance of OptionTag + # + # source://yard-0.9.28/lib/yard/tags/option_tag.rb:7 + def initialize(tag_name, name, pair); end + + # Returns the value of attribute pair. + # + # source://yard-0.9.28/lib/yard/tags/option_tag.rb:5 + def pair; end + + # Sets the attribute pair + # + # @param value the value to set the attribute pair to. + # + # source://yard-0.9.28/lib/yard/tags/option_tag.rb:5 + def pair=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/tags/overload_tag.rb:4 +class YARD::Tags::OverloadTag < ::YARD::Tags::Tag + # @return [OverloadTag] a new instance of OverloadTag + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:7 + def initialize(tag_name, text); end + + # Returns the value of attribute docstring. + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:5 + def docstring; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:15 + def has_tag?(name); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:36 + def is_a?(other); end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:36 + def kind_of?(other); end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:28 + def method_missing(*args, &block); end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:23 + def name(prefix = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:17 + def object=(value); end + + # Returns the value of attribute parameters. + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:5 + def parameters; end + + # Returns the value of attribute signature. + # + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:5 + def signature; end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:13 + def tag(name); end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:14 + def tags(name = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:32 + def type; end + + private + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:53 + def parse_signature; end + + # source://yard-0.9.28/lib/yard/tags/overload_tag.rb:43 + def parse_tag(text); end +end + +# Parses a block of code as if it were present in the source file at that +# location. This directive is useful if a class has dynamic meta-programmed +# behaviour that cannot be recognized by YARD. +# +# You can specify the language of the code block using the types +# specification list. By default, the code language is "ruby". +# +# @example Documenting dynamic module inclusion +# class User +# # includes "UserMixin" and extends "UserMixin::ClassMethods" +# # using the UserMixin.included callback. +# # @!parse include UserMixin +# # @!parse extend UserMixin::ClassMethods +# end +# @example Declaring a method as an attribute +# # This should really be an attribute +# # @!parse attr_reader :foo +# def object; @parent.object end +# @example Parsing C code +# # @!parse [c] +# # void Init_Foo() { +# # rb_define_method(rb_cFoo, "method", method, 0); +# # } +# @since 0.8.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:545 +class YARD::Tags::ParseDirective < ::YARD::Tags::Directive + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:546 + def call; end +end + +# source://yard-0.9.28/lib/yard/tags/ref_tag.rb:4 +module YARD::Tags::RefTag + # Returns the value of attribute owner. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag.rb:5 + def owner; end + + # Sets the attribute owner + # + # @param value the value to set the attribute owner to. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag.rb:5 + def owner=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:4 +class YARD::Tags::RefTagList + # @return [RefTagList] a new instance of RefTagList + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:7 + def initialize(tag_name, owner, name = T.unsafe(nil)); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def name; end + + # Sets the attribute name + # + # @param value the value to set the attribute name to. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def name=(_arg0); end + + # Returns the value of attribute owner. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def owner; end + + # Sets the attribute owner + # + # @param value the value to set the attribute owner to. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def owner=(_arg0); end + + # Returns the value of attribute tag_name. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def tag_name; end + + # Sets the attribute tag_name + # + # @param value the value to set the attribute tag_name to. + # + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:5 + def tag_name=(_arg0); end + + # source://yard-0.9.28/lib/yard/tags/ref_tag_list.rb:13 + def tags; end +end + +# Modifies the current parsing scope (class or instance). If this +# directive is defined on a docstring attached to an object definition, +# it is applied only to that object. Otherwise, it applies the scope +# to all future objects in the namespace. +# +# @example Modifying the scope of a DSL method +# # @!scope class +# cattr_accessor :subclasses +# @example Modifying the scope of a set of methods +# # @!scope class +# +# # Documentation for method1 +# def method1; end +# +# # Documentation for method2 +# def method2; end +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:579 +class YARD::Tags::ScopeDirective < ::YARD::Tags::Directive + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:580 + def call; end +end + +# Represents a metadata tag value (+@tag+). Tags can have any combination of +# {#types}, {#name} and {#text}, or none of the above. +# +# @example Programmatic tag creation +# # The following docstring syntax: +# # @param [String, nil] arg an argument +# # +# # is equivalent to: +# Tag.new(:param, 'an argument', ['String', 'nil'], 'arg') +# +# source://yard-0.9.28/lib/yard/tags/tag.rb:13 +class YARD::Tags::Tag + # Creates a new tag object with a tag name and text. Optionally, formally declared types + # and a key name can be specified. + # + # Types are mainly for meta tags that rely on type information, such as +param+, +return+, etc. + # + # Key names are for tags that declare meta data for a specific key or name, such as +param+, + # +raise+, etc. + # + # @param tag_name [#to_s] the tag name to create the tag for + # @param text [String] the descriptive text for this tag + # @param types [Array<String>] optional type list of formally declared types + # for the tag + # @param name [String] optional key name which the tag refers to + # @return [Tag] a new instance of Tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:44 + def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil)); end + + # Provides a plain English summary of the type specification, or nil + # if no types are provided or parseable. + # + # @return [String] a plain English description of the associated types + # @return [nil] if no types are provided or not parseable + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:65 + def explain_types; end + + # @return [String] a name associated with the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:26 + def name; end + + # @return [String] a name associated with the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:26 + def name=(_arg0); end + + # @return [CodeObjects::Base] the associated object + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:29 + def object; end + + # @return [CodeObjects::Base] the associated object + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:29 + def object=(_arg0); end + + # @return [String] the name of the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:15 + def tag_name; end + + # @return [String] the name of the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:15 + def tag_name=(_arg0); end + + # @return [String] the tag text associated with the tag + # @return [nil] if no tag text is supplied + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:19 + def text; end + + # @return [String] the tag text associated with the tag + # @return [nil] if no tag text is supplied + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:19 + def text=(_arg0); end + + # Convenience method to access the first type specified. This should mainly + # be used for tags that only specify one type. + # + # @return [String] the first of the list of specified types + # @see #types + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:56 + def type; end + + # @return [Array<String>] a list of types associated with the tag + # @return [nil] if no types are associated with the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:23 + def types; end + + # @return [Array<String>] a list of types associated with the tag + # @return [nil] if no types are associated with the tag + # + # source://yard-0.9.28/lib/yard/tags/tag.rb:23 + def types=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/tags/tag_format_error.rb:4 +class YARD::Tags::TagFormatError < ::RuntimeError; end + +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:6 +class YARD::Tags::TypesExplainer + class << self + # Provides a plain English summary of the type specification, or nil + # if no types are provided or parseable. + # + # @param types [Array<String>] a list of types to parse and summarize + # @return [String] a plain English description of the associated types + # @return [nil] if no types are provided or not parseable + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:9 + def explain(*types); end + + # Provides a plain English summary of the type specification, or nil + # if no types are provided or parseable. + # + # @param types [Array<String>] a list of types to parse and summarize + # @raise [SyntaxError] if the types are not parseable + # @return [String] a plain English description of the associated types + # @return [nil] if no types are provided or not parseable + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:17 + def explain!(*types); end + end +end + +# @private +# +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:58 +class YARD::Tags::TypesExplainer::CollectionType < ::YARD::Tags::TypesExplainer::Type + # @return [CollectionType] a new instance of CollectionType + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:61 + def initialize(name, types); end + + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:66 + def to_s(_singular = T.unsafe(nil)); end + + # Returns the value of attribute types. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:59 + def types; end + + # Sets the attribute types + # + # @param value the value to set the attribute types to. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:59 + def types=(_arg0); end +end + +# @private +# +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:72 +class YARD::Tags::TypesExplainer::FixedCollectionType < ::YARD::Tags::TypesExplainer::CollectionType + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:73 + def to_s(_singular = T.unsafe(nil)); end +end + +# @private +# +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:79 +class YARD::Tags::TypesExplainer::HashCollectionType < ::YARD::Tags::TypesExplainer::Type + # @return [HashCollectionType] a new instance of HashCollectionType + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:82 + def initialize(name, key_types, value_types); end + + # Returns the value of attribute key_types. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:80 + def key_types; end + + # Sets the attribute key_types + # + # @param value the value to set the attribute key_types to. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:80 + def key_types=(_arg0); end + + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:88 + def to_s(_singular = T.unsafe(nil)); end + + # Returns the value of attribute value_types. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:80 + def value_types; end + + # Sets the attribute value_types + # + # @param value the value to set the attribute value_types to. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:80 + def value_types=(_arg0); end +end + +# @private +# +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:96 +class YARD::Tags::TypesExplainer::Parser + include ::YARD::CodeObjects + + # @return [Parser] a new instance of Parser + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:117 + def initialize(string); end + + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:121 + def parse; end + + class << self + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:113 + def parse(string); end + end +end + +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:99 +YARD::Tags::TypesExplainer::Parser::TOKENS = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://yard-0.9.28/lib/yard/tags/types_explainer.rb:26 +class YARD::Tags::TypesExplainer::Type + # @return [Type] a new instance of Type + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:29 + def initialize(name); end + + # Returns the value of attribute name. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:27 + def name; end + + # Sets the attribute name + # + # @param value the value to set the attribute name to. + # + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:27 + def name=(_arg0); end + + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:33 + def to_s(singular = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/tags/types_explainer.rb:45 + def list_join(list); end +end + +# Modifies the current parsing visibility (public, protected, or private). +# If this directive is defined on a docstring attached to an object +# definition, it is applied only to that object. Otherwise, it applies +# the visibility to all future objects in the namespace. +# +# @example Modifying the visibility of a DSL method +# # @!visibility private +# cattr_accessor :subclasses +# @example Modifying the visibility of a set of methods +# # Note that Ruby's "protected" is recommended over this directive +# # @!visibility protected +# +# # Documentation for method1 +# def method1; end +# +# # Documentation for method2 +# def method2; end +# @since 0.7.0 +# +# source://yard-0.9.28/lib/yard/tags/directives.rb:611 +class YARD::Tags::VisibilityDirective < ::YARD::Tags::Directive + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/tags/directives.rb:612 + def call; end +end + +# Namespace for templating system +# +# source://yard-0.9.28/lib/yard/autoload.rb:270 +module YARD::Templates; end + +# This module manages all creation, handling and rendering of {Template} +# objects. +# +# * To create a template object at a path, use {template}. +# * To render a template, call {render}. +# * To register a template path in the lookup paths, call {register_template_path}. +# +# source://yard-0.9.28/lib/yard/templates/engine.rb:12 +module YARD::Templates::Engine + class << self + # Passes a set of objects to the +:fulldoc+ template for full documentation generation. + # This is called by {CLI::Yardoc} to most commonly perform HTML + # documentation generation. + # + # @param objects [Array<CodeObjects::Base>] a list of {CodeObjects::Base} + # objects to pass to the template + # @param options [Hash] (see {render}) + # @return [void] + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:101 + def generate(objects, options = T.unsafe(nil)); end + + # Registers a new template path in {template_paths} + # + # @param path [String] a new template path + # @return [void] + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:21 + def register_template_path(path); end + + # Renders a template on a {CodeObjects::Base code object} using + # a set of default (overridable) options. Either the +:object+ + # or +:type+ keys must be provided. + # + # If a +:serializer+ key is provided and +:serialize+ is not set to + # false, the rendered contents will be serialized through the {Serializers::Base} + # object. See {with_serializer}. + # + # @example Renders an object with html formatting + # Engine.render(:format => :html, :object => obj) + # @example Renders without an object + # Engine.render(:type => :fulldoc, :otheropts => somevalue) + # @option options + # @option options + # @option options + # @param options [Hash] the options hash + # @return [String] the rendered template + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:82 + def render(options = T.unsafe(nil)); end + + # Creates a template module representing the path. Searches on disk + # for the first directory named +path+ (joined by '/') within the + # template paths and builds a template module for. All other matching + # directories in other template paths will be included in the + # generated module as mixins (for overriding). + # + # @param path [Array<String, Symbol>] a list of path components + # @raise [ArgumentError] if the path does not exist within one of the + # {template_paths} on disk. + # @return [Template] the module representing the template + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:35 + def template(*path); end + + # Forces creation of a template at +path+ within a +full_path+. + # + # @param path [String] the path name of the template + # @param full_paths [Array<String>] the full path on disk of the template + # @return [Template] the template module representing the +path+ + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:53 + def template!(path, full_paths = T.unsafe(nil)); end + + # @return [Array<String>] the list of registered template paths + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:15 + def template_paths; end + + # @return [Array<String>] the list of registered template paths + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:15 + def template_paths=(_arg0); end + + # Serializes the results of a block with a +serializer+ object. + # + # @param object [CodeObjects::Base] the code object to serialize + # @param serializer [Serializers::Base] the serializer object + # @see Serializers::Base + # @yield a block whose result will be serialize + # @yieldreturn [String] the contents to serialize + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:115 + def with_serializer(object, serializer); end + + private + + # Searches through the registered {template_paths} and returns + # all full directories that have the +path+ within them on disk. + # + # @param from_template [Template] if provided, allows a relative + # path to be specified from this template's full path. + # @param path [String] the path component to search for in the + # {template_paths} + # @return [Array<String>] a list of full paths that are existing + # candidates for a template module + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:161 + def find_template_paths(from_template, path); end + + # Sets default options on the options hash + # + # @option options + # @option options + # @option options + # @param options [Hash] the options hash + # @return [void] + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:141 + def set_default_options(options = T.unsafe(nil)); end + + # The name of the module that represents a +path+ + # + # @param path [String] the path to generate a module name for + # @return [String] the module name + # + # source://yard-0.9.28/lib/yard/templates/engine.rb:176 + def template_module_name(path); end + end +end + +# @since 0.5.4 +# +# source://yard-0.9.28/lib/yard/templates/erb_cache.rb:5 +module YARD::Templates::ErbCache + class << self + # @since 0.5.4 + # + # source://yard-0.9.28/lib/yard/templates/erb_cache.rb:17 + def clear!; end + + # @since 0.5.4 + # + # source://yard-0.9.28/lib/yard/templates/erb_cache.rb:6 + def method_for(filename); end + end +end + +# Namespace for template helpers +# +# source://yard-0.9.28/lib/yard/autoload.rb:271 +module YARD::Templates::Helpers; end + +# The base helper module included in all templates. +# +# source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:4 +module YARD::Templates::Helpers::BaseHelper + # @example + # s = format_object_title ModuleObject.new(:root, :MyModuleName) + # s # => "Module: MyModuleName" + # @param object [CodeObjects::Base] the object to retrieve a title for + # @return [String] the page title name for a given object + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:196 + def format_object_title(object); end + + # @example Formatted type of an exception class + # o = ClassObject.new(:root, :MyError) + # o.superclass = P('RuntimeError') + # format_object_type(o) # => "Exception" + # @example Formatted type of a method + # o = MethodObject.new(:root, :to_s) + # format_object_type(o) # => "Method" + # @param object [CodeObjects::Base] the object to retrieve the type for + # @return [String] the human-readable formatted {CodeObjects::Base#type #type} + # for the object + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:182 + def format_object_type(object); end + + # Indents and formats source code + # + # @param value [String] the input source code + # @return [String] formatted source code + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:209 + def format_source(value); end + + # Formats a list of return types for output and links each type. + # + # @example Formatting types + # format_types(['String', 'Array']) #=> "(String, Array)" + # @example Formatting types without surrounding brackets + # format_types(['String', 'Array'], false) #=> "String, Array" + # @param list [Array<String>] a list of types + # @param brackets [Boolean] whether to surround the types in brackets + # @return [String] the formatted list of Ruby types + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:168 + def format_types(list, brackets = T.unsafe(nil)); end + + # An object that keeps track of global state throughout the entire template + # rendering process (including any sub-templates). + # + # @return [OpenStruct] a struct object that stores state + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:20 + def globals; end + + # Escapes text. This is used a lot by the HtmlHelper and there should + # be some helper to "clean up" text for whatever, this is it. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:38 + def h(text); end + + # Links to an extra file + # + # @param filename [String] the filename to link to + # @param title [String] the title of the link + # @param anchor [String] optional anchor + # @return [String] the link to the file + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:152 + def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end + + # Include a file as a docstring in output + # + # @param file [String] the filename to include + # @return [String] the file's contents + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:113 + def link_include_file(file); end + + # Includes an object's docstring into output. + # + # @param obj [CodeObjects::Base] the object to include + # @return [String] the object's docstring (no tags) + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:105 + def link_include_object(obj); end + + # Links to an object with an optional title + # + # @param obj [CodeObjects::Base] the object to link to + # @param title [String] the title to use for the link + # @return [String] the linked object + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:122 + def link_object(obj, title = T.unsafe(nil)); end + + # Links to a URL + # + # @param url [String] the URL to link to + # @param title [String] the optional title to display the link as + # @param params [Hash] optional parameters for the link + # @return [String] the linked URL + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:141 + def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end + + # Links objects or URLs. This method will delegate to the correct +link_+ + # method depending on the arguments passed in. + # + # @example Linking a URL + # linkify('http://example.com') + # @example Including docstring contents of an object + # linkify('include:YARD::Docstring') + # @example Linking to an extra file + # linkify('file:README') + # @example Linking an object by path + # linkify('YARD::Docstring') + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:55 + def linkify(*args); end + + # Returns the value of attribute object. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:5 + def object; end + + # Sets the attribute object + # + # @param value the value to set the attribute object to. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:5 + def object=(_arg0); end + + # @return [CodeObjects::Base] the object representing the current generated + # page. Might not be the current {#object} when inside sub-templates. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:11 + def owner; end + + # Runs a list of objects against the {Verifier} object passed into the + # template and returns the subset of verified objects. + # + # @param list [Array<CodeObjects::Base>] a list of code objects + # @return [Array<CodeObjects::Base>] a list of code objects that match + # the verifier. If no verifier is supplied, all objects are returned. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:30 + def run_verifier(list); end + + # Returns the value of attribute serializer. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:5 + def serializer; end + + # Sets the attribute serializer + # + # @param value the value to set the attribute serializer to. + # + # source://yard-0.9.28/lib/yard/templates/helpers/base_helper.rb:5 + def serializer=(_arg0); end +end + +# Helpers for various object types +# +# source://yard-0.9.28/lib/yard/templates/helpers/filter_helper.rb:5 +module YARD::Templates::Helpers::FilterHelper + # @return [Boolean] whether an object is a class + # + # source://yard-0.9.28/lib/yard/templates/helpers/filter_helper.rb:17 + def is_class?(object); end + + # @return [Boolean] whether an object is a method + # + # source://yard-0.9.28/lib/yard/templates/helpers/filter_helper.rb:7 + def is_method?(object); end + + # @return [Boolean] whether an object is a module + # + # source://yard-0.9.28/lib/yard/templates/helpers/filter_helper.rb:22 + def is_module?(object); end + + # @return [Boolean] whether an object is a namespace + # + # source://yard-0.9.28/lib/yard/templates/helpers/filter_helper.rb:12 + def is_namespace?(object); end +end + +# The helper module for HTML templates. +# +# source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:7 +module YARD::Templates::Helpers::HtmlHelper + include ::YARD::Templates::Helpers::MarkupHelper + include ::YARD::Templates::Helpers::ModuleHelper + include ::YARD::Templates::Helpers::HtmlSyntaxHighlightHelper + + # @param object [CodeObjects::Base] the object to get an anchor for + # @return [String] the anchor for a specific object + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:347 + def anchor_for(object); end + + # Returns the current character set. The default value can be overridden + # by setting the +LANG+ environment variable or by overriding this + # method. In Ruby 1.9 you can also modify this value by setting + # +Encoding.default_external+. + # + # @return [String] the current character set + # @since 0.5.4 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:574 + def charset; end + + # Formats a list of objects and links them + # + # @return [String] a formatted list of objects + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:458 + def format_object_name_list(objects); end + + # Formats a list of types from a tag. + # + # @param typelist [Array<String>, FalseClass] the list of types to be formatted. + # @param brackets [Boolean] omits the surrounding + # brackets if +brackets+ is set to +false+. + # @return [String] the list of types formatted + # as [Type1, Type2, ...] with the types linked + # to their respective descriptions. + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:476 + def format_types(typelist, brackets = T.unsafe(nil)); end + + # Escapes HTML entities + # + # @param text [String] the text to escape + # @return [String] the HTML with escaped entities + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:23 + def h(text); end + + # Converts Asciidoc to HTML + # + # @param text [String] input Asciidoc text + # @return [String] output HTML + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:109 + def html_markup_asciidoc(text); end + + # Converts HTML to HTML + # + # @param text [String] input html + # @return [String] output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:168 + def html_markup_html(text); end + + # Converts Markdown to HTML + # + # @param text [String] input Markdown text + # @return [String] output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:78 + def html_markup_markdown(text); end + + # @return [String] the same text with no markup + # @since 0.6.6 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:160 + def html_markup_none(text); end + + # Converts org-mode to HTML + # + # @param text [String] input org-mode text + # @return [String] output HTML + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:102 + def html_markup_org(text); end + + # Converts plaintext to pre-formatted HTML + # + # @param text [String] the input text + # @return [String] the output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:146 + def html_markup_pre(text); end + + # Converts RDoc formatting (SimpleMarkup) to HTML + # + # @param text [String] the input RDoc formatted text + # @return [String] output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:136 + def html_markup_rdoc(text); end + + # Highlights Ruby source. Similar to {#html_syntax_highlight}, but + # this method is meant to be called from {#htmlify} when markup is + # set to "ruby". + # + # @param source [String] the Ruby source + # @return [String] the highlighted HTML + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:179 + def html_markup_ruby(source); end + + # Converts plaintext to regular HTML + # + # @param text [String] the input text + # @return [String] the output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:154 + def html_markup_text(text); end + + # Converts Textile to HTML + # + # @param text [String] the input Textile text + # @return [String] output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:118 + def html_markup_textile(text); end + + # Converts plaintext to strict Textile (hard breaks) + # + # @param text [String] the input textile data + # @return [String] the output HTML + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:128 + def html_markup_textile_strict(text); end + + # Syntax highlights +source+ in language +type+. + # + # @note To support a specific language +type+, implement the method + # +html_syntax_highlight_TYPE+ in this class. + # @param source [String] the source code to highlight + # @param type [Symbol, String] the language type (:ruby, :plain, etc). Use + # :plain for no syntax highlighting. + # @return [String] the highlighted source + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:199 + def html_syntax_highlight(source, type = T.unsafe(nil)); end + + # @return [String] unhighlighted source + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:210 + def html_syntax_highlight_plain(source); end + + # Turns text into HTML using +markup+ style formatting. + # + # @param text [String] the text to format + # @param markup [Symbol] examples are +:markdown+, +:textile+, +:rdoc+. + # To add a custom markup type, see {MarkupHelper} + # @return [String] the HTML + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:57 + def htmlify(text, markup = T.unsafe(nil)); end + + # @return [String] HTMLified text as a single line (paragraphs removed) + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:184 + def htmlify_line(*args); end + + # Inserts an include link while respecting inlining + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:296 + def insert_include(text, markup = T.unsafe(nil)); end + + # Links to an extra file + # + # @param filename [String] the filename to link to + # @param title [String] the title of the link + # @param anchor [String] optional anchor + # @return [String] the link to the file + # @since 0.5.5 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:270 + def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end + + # Include a file as a docstring in output + # + # @param file [String] the filename to include + # @return [String] the file's contents + # @since 0.7.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:282 + def link_include_file(file); end + + # Includes an object's docstring into output. + # + # @param obj [CodeObjects::Base] the object to include + # @return [String] the object's docstring (no tags) + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:291 + def link_include_object(obj); end + + # Links to an object with an optional title + # + # @param obj [CodeObjects::Base] the object to link to + # @param title [String] the title to use for the link + # @return [String] the linked object + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:301 + def link_object(obj, title = T.unsafe(nil), anchor = T.unsafe(nil), relative = T.unsafe(nil)); end + + # Links to a URL + # + # @param url [String] the URL to link to + # @param title [String] the optional title to display the link as + # @param params [Hash] optional parameters for the link + # @return [String] the linked URL + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:332 + def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end + + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:400 + def mtime(_file); end + + # Returns the URL for an object. + # + # @param obj [String, CodeObjects::Base] the object (or object path) to link to + # @param anchor [String] the anchor to link to + # @param relative [Boolean] use a relative or absolute link + # @return [String] the URL location of the object + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:368 + def mtime_url(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end + + # Resolves any text in the form of +{Name}+ to the object specified by + # Name. Also supports link titles in the form +{Name title}+. + # + # @example Linking to an instance method + # resolve_links("{MyClass#method}") # => "<a href='...'>MyClass#method</a>" + # @example Linking to a class with a title + # resolve_links("{A::B::C the C class}") # => "<a href='...'>the c class</a>" + # @param text [String] the text to resolve links in + # @return [String] HTML with linkified references + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:225 + def resolve_links(text); end + + # Formats the signature of method +meth+. + # + # @param meth [CodeObjects::MethodObject] the method object to list + # the signature of + # @param link [Boolean] whether to link the method signature to the details view + # @param show_extras [Boolean] whether to show extra meta-data (visibility, attribute info) + # @param full_attr_name [Boolean] whether to show the full attribute name + # ("name=" instead of "name") + # @return [String] the formatted method signature + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:529 + def signature(meth, link = T.unsafe(nil), show_extras = T.unsafe(nil), full_attr_name = T.unsafe(nil)); end + + # Get the return types for a method signature. + # + # @param meth [CodeObjects::MethodObject] the method object + # @param link [Boolean] whether to link the types + # @return [String] the signature types + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:492 + def signature_types(meth, link = T.unsafe(nil)); end + + # Returns the URL for an object. + # + # @param obj [String, CodeObjects::Base] the object (or object path) to link to + # @param anchor [String] the anchor to link to + # @param relative [Boolean] use a relative or absolute link + # @return [String] the URL location of the object + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:368 + def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end + + # Returns the URL for a specific file + # + # @param filename [String, CodeObjects::ExtraFileObject] the filename to link to + # @param anchor [String] optional anchor + # @return [String] the URL pointing to the file + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:407 + def url_for_file(filename, anchor = T.unsafe(nil)); end + + # Returns the URL for the frameset page + # + # @return [String] the URL pointing to the frames page + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:434 + def url_for_frameset; end + + # Returns the URL for the alphabetic index page + # + # @return [String] the URL pointing to the first main page the + # user should see. + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:450 + def url_for_index; end + + # Returns the URL for a list type + # + # @param type [String, Symbol] the list type to generate a URL for + # @return [String] the URL pointing to the list + # @since 0.8.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:426 + def url_for_list(type); end + + # Returns the URL for the main page (README or alphabetic index) + # + # @return [String] the URL pointing to the first main page the + # user should see. + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:442 + def url_for_main; end + + private + + # Converts a {CodeObjects::MethodObject} into an overload object + # + # @since 0.5.3 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:609 + def convert_method_to_overload(meth); end + + # Parses code block's HTML attributes in order to detect the programming + # language of what's enclosed in that code block. + # + # @param pre_html_attrs [String, nil] HTML attribute list of +pre+ element + # @param code_html_attrs [String, nil] HTML attribute list of +code+ + # element + # @return [String, nil] detected programming language + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:664 + def detect_lang_in_codeblock_attributes(pre_html_attrs, code_html_attrs); end + + # Parses code blocks out of html and performs syntax highlighting + # on code inside of the blocks. + # + # @param html [String] the html to search for code in + # @return [String] highlighted html + # @see #html_syntax_highlight + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:640 + def parse_codeblocks(html); end + + # Parses !!!lang out of codeblock, returning the codeblock language + # followed by the source code. + # + # @param source [String] the source code whose language to determine + # @return [Array(String, String)] the language, if any, and the + # remaining source + # @since 0.7.5 + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:624 + def parse_lang_for_codeblock(source); end + + # Converts a set of hash options into HTML attributes for a tag + # + # @param opts [Hash{String => String}] the tag options + # @return [String] the tag attributes of an HTML tag + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:603 + def tag_attrs(opts = T.unsafe(nil)); end + + # Escapes a URL + # + # @param text [String] the URL + # @return [String] the escaped URL + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:31 + def urlencode(text); end + + class << self + # Escapes a URL + # + # @param text [String] the URL + # @return [String] the escaped URL + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:31 + def urlencode(text); end + end +end + +# @private +# +# source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:15 +YARD::Templates::Helpers::HtmlHelper::ASCIIDOC_ATTRIBUTES = T.let(T.unsafe(nil), Hash) + +# @private +# +# source://yard-0.9.28/lib/yard/templates/helpers/html_helper.rb:12 +YARD::Templates::Helpers::HtmlHelper::URLMATCH = T.let(T.unsafe(nil), Regexp) + +# Helper methods for syntax highlighting. +# +# source://yard-0.9.28/lib/yard/templates/helpers/html_syntax_highlight_helper.rb:6 +module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper + include ::YARD::Templates::Helpers::ModuleHelper + + # Highlights Ruby source + # + # @param source [String] the Ruby source code + # @return [String] the highlighted Ruby source + # + # source://yard-0.9.28/lib/yard/templates/helpers/html_syntax_highlight_helper.rb:12 + def html_syntax_highlight_ruby(source); end + + private + + # source://yard-0.9.28/lib/yard/templates/helpers/html_syntax_highlight_helper.rb:63 + def clean_token_object(token_obj); end + + # source://yard-0.9.28/lib/yard/templates/helpers/html_syntax_highlight_helper.rb:45 + def html_syntax_highlight_ruby_legacy(source); end + + # source://yard-0.9.28/lib/yard/templates/helpers/html_syntax_highlight_helper.rb:22 + def html_syntax_highlight_ruby_ripper(source); end +end + +# Namespace for markup providers +# +# source://yard-0.9.28/lib/yard/autoload.rb:272 +module YARD::Templates::Helpers::Markup; end + +# source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markdown.rb:13 +class YARD::Templates::Helpers::Markup::RDocMarkdown < ::YARD::Templates::Helpers::Markup::RDocMarkup + # @return [RDocMarkdown] a new instance of RDocMarkdown + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markdown.rb:14 + def initialize(text); end + + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markdown.rb:18 + def fix_typewriter(html); end +end + +# source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:12 +class YARD::Templates::Helpers::Markup::RDocMarkup + # @return [RDocMarkup] a new instance of RDocMarkup + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:41 + def initialize(text); end + + # Returns the value of attribute from_path. + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:35 + def from_path; end + + # Sets the attribute from_path + # + # @param value the value to set the attribute from_path to. + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:35 + def from_path=(_arg0); end + + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:50 + def to_html; end + + private + + # Don't allow -- to turn into — element. The chances of this being + # some --option is far more likely than the typographical meaning. + # + # @todo Refactor into own SimpleMarkup subclass + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:87 + def fix_dash_dash(text); end + + # Fixes RDoc behaviour with ++ only supporting alphanumeric text. + # + # @todo Refactor into own SimpleMarkup subclass + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:66 + def fix_typewriter(text); end +end + +# source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:12 +YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP = RDoc::Markup + +# source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:13 +class YARD::Templates::Helpers::Markup::RDocMarkupToHtml < ::RDoc::Markup::ToHtml + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:16 + def initialize; end + + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:100 + def accept_paragraph(*args); end + + # Returns the value of attribute from_path. + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:93 + def from_path; end + + # Sets the attribute from_path + # + # @param value the value to set the attribute from_path to. + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:93 + def from_path=(_arg0); end + + # Disable auto-link of URLs + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup/rdoc_markup.rb:96 + def handle_special_HYPERLINK(special); end +end + +# Helper methods for loading and managing markup types. +# +# source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:7 +module YARD::Templates::Helpers::MarkupHelper + # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}. + # If a provider is specified, immediately try to load it. + # + # On success this sets `@markup_provider` and `@markup_class` to + # the provider name and library constant class/module respectively for + # the loaded provider. + # + # On failure this method will inform the user that no provider could be + # found and exit the program. + # + # @return [Boolean] whether the markup provider was successfully loaded. + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:87 + def load_markup_provider(type = T.unsafe(nil)); end + + # Gets the markup provider class/module constant for a markup type + # Call {#load_markup_provider} before using this method. + # + # @param type [Symbol] the markup type (:rdoc, :markdown, etc.) + # @return [Class] the markup class + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:158 + def markup_class(type = T.unsafe(nil)); end + + # Strips any shebang lines on the file contents that pertain to + # markup or preprocessing data. + # + # @deprecated Use {CodeObjects::ExtraFileObject#contents} instead + # @return [String] the file contents minus any preprocessing tags + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:149 + def markup_file_contents(contents); end + + # Checks for a shebang or looks at the file extension to determine + # the markup type for the file contents. File extensions are registered + # for a markup type in {MARKUP_EXTENSIONS}. + # + # A shebang should be on the first line of a file and be in the form: + # + # #!markup_type + # + # Standard markup types are text, html, rdoc, markdown, textile + # + # @param contents [String] Unused. Was necessary prior to 0.7.0. + # Newer versions of YARD use {CodeObjects::ExtraFileObject#contents} + # @return [Symbol] the markup type recognized for the file + # @see MARKUP_EXTENSIONS + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:133 + def markup_for_file(contents, filename); end + + # Gets the markup provider name for a markup type + # Call {#load_markup_provider} before using this method. + # + # @param type [Symbol] the markup type (:rdoc, :markdown, etc.) + # @return [Symbol] the markup provider name (usually the gem name of the library) + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:168 + def markup_provider(type = T.unsafe(nil)); end + + class << self + # Clears the markup provider cache information. Mainly used for testing. + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:11 + def clear_markup_cache; end + + # @private + # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers + # @since 0.6.4 + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:18 + def markup_cache; end + + # @private + # @return [Hash{Symbol=>{(:provider,:class)=>Object}}] the cached markup providers + # @since 0.6.4 + # + # source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:18 + def markup_cache=(_arg0); end + end +end + +# Returns a list of extensions for various markup types. To register +# extensions for a type, add them to the array of extensions for the +# type. +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:61 +YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS = T.let(T.unsafe(nil), Hash) + +# Contains the Regexp object that matches the shebang line of extra +# files to detect the markup type. +# +# source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:74 +YARD::Templates::Helpers::MarkupHelper::MARKUP_FILE_SHEBANG = T.let(T.unsafe(nil), Regexp) + +# The default list of markup providers for each markup type +# +# source://yard-0.9.28/lib/yard/templates/helpers/markup_helper.rb:24 +YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS = T.let(T.unsafe(nil), Hash) + +# Helper methods for method objects. +# +# source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:5 +module YARD::Templates::Helpers::MethodHelper + # @return [String] formatted arguments for a method + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:7 + def format_args(object); end + + # @return [String] formatted block if one exists + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:35 + def format_block(object); end + + # @return [String] formats source of an object + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:57 + def format_code(object, _show_lines = T.unsafe(nil)); end + + # @return [String] formats source code of a constant value + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:68 + def format_constant(value); end + + # @return [String] formats line numbers for source code of an object + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:50 + def format_lines(object); end + + # @return [String] formatted and linked return types for a method + # + # source://yard-0.9.28/lib/yard/templates/helpers/method_helper.rb:28 + def format_return_types(object); end +end + +# Helper methods for managing module objects. +# +# source://yard-0.9.28/lib/yard/templates/helpers/module_helper.rb:6 +module YARD::Templates::Helpers::ModuleHelper + # Prunes the method listing by running the verifier and removing attributes/aliases + # + # @param list [Array<CodeObjects::Base>] a list of methods + # @param hide_attributes [Boolean] whether to prune attribute methods from the list + # @return [Array<CodeObjects::Base>] a pruned list of methods + # + # source://yard-0.9.28/lib/yard/templates/helpers/module_helper.rb:11 + def prune_method_listing(list, hide_attributes = T.unsafe(nil)); end +end + +# Helper methods for text template formats. +# +# source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:6 +module YARD::Templates::Helpers::TextHelper + # @return [String] aligns text to the right + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:39 + def align_right(text, spacer = T.unsafe(nil), col = T.unsafe(nil)); end + + # @return [String] escapes text + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:8 + def h(text); end + + # @return [String] returns a horizontal rule for output + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:45 + def hr(col = T.unsafe(nil), sep = T.unsafe(nil)); end + + # @return [String] indents +text+ by +len+ characters. + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:29 + def indent(text, len = T.unsafe(nil)); end + + # @return [String] the formatted signature for a method + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:50 + def signature(meth); end + + # @return [String] aligns a title to the right + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:34 + def title_align_right(text, col = T.unsafe(nil)); end + + # @return [String] wraps text at +col+ columns. + # + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:24 + def wrap(text, col = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/templates/helpers/text_helper.rb:98 + def resolve_links(text); end +end + +# Helpers for UML template format +# +# source://yard-0.9.28/lib/yard/templates/helpers/uml_helper.rb:5 +module YARD::Templates::Helpers::UMLHelper + # Formats the path of an object for Graphviz syntax + # + # @param object [CodeObjects::Base] an object to format the path of + # @return [String] the encoded path + # + # source://yard-0.9.28/lib/yard/templates/helpers/uml_helper.rb:20 + def format_path(object); end + + # Encodes text in escaped Graphviz syntax + # + # @param text [String] text to encode + # @return [String] the encoded text + # + # source://yard-0.9.28/lib/yard/templates/helpers/uml_helper.rb:27 + def h(text); end + + # Tidies data by formatting and indenting text + # + # @param data [String] pre-formatted text + # @return [String] tidied text. + # + # source://yard-0.9.28/lib/yard/templates/helpers/uml_helper.rb:34 + def tidy(data); end + + # Official UML visibility prefix syntax for an object given its visibility + # + # @param object [CodeObjects::Base] the object to retrieve visibility for + # @return [String] the UML visibility prefix + # + # source://yard-0.9.28/lib/yard/templates/helpers/uml_helper.rb:9 + def uml_visibility(object); end +end + +# Abstracts the structure for a section and its subsections into an ordered +# list of sections and subsections. +# +# @since 0.6.0 +# +# source://yard-0.9.28/lib/yard/templates/section.rb:7 +class YARD::Templates::Section < ::Array + # @return [Section] a new instance of Section + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:10 + def initialize(name, *args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:45 + def <<(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:34 + def ==(other); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:21 + def [](*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:74 + def any(item); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:15 + def dup; end + + # @return [Boolean] + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:30 + def eql?(other); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:54 + def inspect; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:8 + def name; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:8 + def name=(_arg0); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:60 + def place(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:45 + def push(*args); end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:64 + def to_a; end + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:50 + def unshift(*args); end + + private + + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/section.rb:84 + def parse_sections(args); end +end + +# source://yard-0.9.28/lib/yard/templates/template.rb:6 +module YARD::Templates::Template + include ::YARD::Templates::ErbCache + include ::YARD::Templates::Helpers::BaseHelper + include ::YARD::Templates::Helpers::MethodHelper + + mixes_in_class_methods ::YARD::Templates::Template::ClassMethods + + # source://yard-0.9.28/lib/yard/templates/template.rb:186 + def initialize(opts = T.unsafe(nil)); end + + # Loads a template specified by path. If +:template+ or +:format+ is + # specified in the {#options} hash, they are prepended and appended + # to the path respectively. + # + # @param path [Array<String, Symbol>] the path of the template + # @return [Template] the loaded template module + # + # source://yard-0.9.28/lib/yard/templates/template.rb:204 + def T(*path); end + + # Returns the value of attribute class. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:7 + def class; end + + # Sets the attribute class + # + # @param value the value to set the attribute class to. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:7 + def class=(_arg0); end + + # @param section [String, Symbol] the section name + # @return [String] the contents of the ERB rendered section + # @yield calls subsections to be rendered + # + # source://yard-0.9.28/lib/yard/templates/template.rb:285 + def erb(section, &block); end + + # Returns the contents of a file. If +allow_inherited+ is set to +true+, + # use +{{{__super__}}}+ inside the file contents to insert the contents + # of the file from an inherited template. For instance, if +templates/b+ + # inherits from +templates/a+ and file "test.css" exists in both directories, + # both file contents can be retrieved by having +templates/b/test.css+ look + # like: + # + # {{{__super__}}} + # ... + # body { css styles here } + # p.class { other styles } + # + # @param basename [String] the name of the file + # @param allow_inherited [Boolean] whether inherited templates can + # be inserted with +{{{__super__}}}+ + # @raise [ArgumentError] + # @return [String] the contents of a file identified by +basename+. All + # template paths (including any mixed in templates) are searched for + # the file + # @see ClassMethods#find_file + # @see ClassMethods#find_nth_file + # + # source://yard-0.9.28/lib/yard/templates/template.rb:312 + def file(basename, allow_inherited = T.unsafe(nil)); end + + # Initialization called on the template. Override this in a 'setup.rb' + # file in the template's path to implement a template + # + # @example A default set of sections + # def init + # sections :section1, :section2, [:subsection1, :etc] + # end + # @see #sections + # + # source://yard-0.9.28/lib/yard/templates/template.rb:239 + def init; end + + # source://yard-0.9.28/lib/yard/templates/template.rb:342 + def inspect; end + + # Returns the value of attribute options. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:8 + def options; end + + # source://yard-0.9.28/lib/yard/templates/template.rb:337 + def options=(value); end + + # Runs a template on +sects+ using extra options. This method should + # not be called directly. Instead, call the class method {ClassMethods#run} + # + # @param opts [Hash, nil] any extra options to apply to sections + # @param sects [Section, Array] a section list of sections to render + # @param start_at [Fixnum] the index in the section list to start from + # @param break_first [Boolean] if true, renders only the first section + # @return [String] the rendered sections joined together + # @yield [opts] calls for the subsections to be rendered + # @yieldparam opts [Hash] any extra options to yield + # + # source://yard-0.9.28/lib/yard/templates/template.rb:252 + def run(opts = T.unsafe(nil), sects = T.unsafe(nil), start_at = T.unsafe(nil), break_first = T.unsafe(nil), &block); end + + # Returns the value of attribute section. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:7 + def section; end + + # Sets the attribute section + # + # @param value the value to set the attribute section to. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:7 + def section=(_arg0); end + + # Sets the sections (and subsections) to be rendered for the template + # + # @example Sets a set of erb sections + # sections :a, :b, :c # searches for a.erb, b.erb, c.erb + # @example Sets a set of method and erb sections + # sections :a, :b, :c # a is a method, the rest are erb files + # @example Sections with subsections + # sections :header, [:name, :children] + # # the above will call header.erb and only renders the subsections + # # if they are yielded by the template (see #yieldall) + # @param args [Array<Symbol, String, Template, Array>] the sections + # to use to render the template. For symbols and strings, the + # section will be executed as a method (if one exists), or rendered + # from the file "name.erb" where name is the section name. For + # templates, they will have {Template::ClassMethods#run} called on them. + # Any subsections can be yielded to using yield or {#yieldall} + # + # source://yard-0.9.28/lib/yard/templates/template.rb:226 + def sections(*args); end + + # Calls the ERB file from the last inherited template with {#section}.erb + # + # @param sect [Symbol, String] if provided, uses a specific section name + # @return [String] the rendered ERB file in any of the inherited template + # paths. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:330 + def superb(sect = T.unsafe(nil), &block); end + + # Yields all subsections with any extra options + # + # @param opts [Hash] extra options to be applied to subsections + # + # source://yard-0.9.28/lib/yard/templates/template.rb:278 + def yieldall(opts = T.unsafe(nil), &block); end + + protected + + # source://yard-0.9.28/lib/yard/templates/template.rb:348 + def erb_file_for(section); end + + # source://yard-0.9.28/lib/yard/templates/template.rb:352 + def erb_with(content, filename = T.unsafe(nil)); end + + private + + # source://yard-0.9.28/lib/yard/templates/template.rb:399 + def add_options(opts = T.unsafe(nil)); end + + # @raise [ArgumentError] + # + # source://yard-0.9.28/lib/yard/templates/template.rb:378 + def cache(section); end + + # source://yard-0.9.28/lib/yard/templates/template.rb:388 + def cache_filename(section); end + + # source://yard-0.9.28/lib/yard/templates/template.rb:364 + def render_section(section, &block); end + + # source://yard-0.9.28/lib/yard/templates/template.rb:393 + def set_ivars; end + + # source://yard-0.9.28/lib/yard/templates/template.rb:412 + def with_section; end + + class << self + # Extra includes are mixins that are included after a template is created. These + # mixins can be registered by plugins to operate on templates and override behaviour. + # + # Note that this array can be filled with modules or proc objects. If a proc object + # is given, the proc will be called with the {Template#options} hash containing + # relevant template information like the object, format, and more. The proc should + # return a module or nil if there is none. + # + # @example Adding in extra mixins to include on a template + # Template.extra_includes << MyHelper + # @example Conditionally including a mixin if the format is html + # Template.extra_includes << proc {|opts| MyHelper if opts.format == :html } + # @return [Array<Module, Proc>] a list of modules to be automatically included + # into any new template module + # + # source://yard-0.9.28/lib/yard/templates/template.rb:25 + def extra_includes; end + + # Extra includes are mixins that are included after a template is created. These + # mixins can be registered by plugins to operate on templates and override behaviour. + # + # Note that this array can be filled with modules or proc objects. If a proc object + # is given, the proc will be called with the {Template#options} hash containing + # relevant template information like the object, format, and more. The proc should + # return a module or nil if there is none. + # + # @example Adding in extra mixins to include on a template + # Template.extra_includes << MyHelper + # @example Conditionally including a mixin if the format is html + # Template.extra_includes << proc {|opts| MyHelper if opts.format == :html } + # @return [Array<Module, Proc>] a list of modules to be automatically included + # into any new template module + # + # source://yard-0.9.28/lib/yard/templates/template.rb:25 + def extra_includes=(_arg0); end + + # Includes the {extra_includes} modules into the template object. + # + # @param template [Template] the template object to mixin the extra includes. + # @param options [SymbolHash] the options hash containing all template information + # @return [void] + # + # source://yard-0.9.28/lib/yard/templates/template.rb:38 + def include_extra(template, options); end + + # @private + # @private + # + # source://yard-0.9.28/lib/yard/templates/template.rb:29 + def included(klass); end + end +end + +# source://yard-0.9.28/lib/yard/templates/template.rb:59 +module YARD::Templates::Template::ClassMethods + # source://yard-0.9.28/lib/yard/templates/template.rb:81 + def initialize(path, full_paths); end + + # Alias for creating a {Section} with arguments + # + # @see Section#initialize + # @since 0.6.0 + # + # source://yard-0.9.28/lib/yard/templates/template.rb:149 + def S(*args); end + + # Alias for creating {Engine.template}. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:142 + def T(*path); end + + # Searches for a file identified by +basename+ in the template's + # path as well as any mixed in template paths. Equivalent to calling + # {ClassMethods#find_nth_file} with index of 1. + # + # @param basename [String] the filename to search for + # @return [String] the full path of a file on disk with filename + # +basename+ in one of the template's paths. + # @see find_nth_file + # + # source://yard-0.9.28/lib/yard/templates/template.rb:98 + def find_file(basename); end + + # Searches for the nth file (where n = +index+) identified + # by basename in the template's path and any mixed in template paths. + # + # @param basename [String] the filename to search for + # @param index [Fixnum] the nth existing file to return + # @return [String] the full path of the nth file on disk with + # filename +basename+ in one of the template paths + # + # source://yard-0.9.28/lib/yard/templates/template.rb:109 + def find_nth_file(basename, index = T.unsafe(nil)); end + + # Returns the value of attribute full_path. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:60 + def full_path; end + + # Sets the attribute full_path + # + # @param value the value to set the attribute full_path to. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:60 + def full_path=(_arg0); end + + # @note This method caches path results. Paths should not be modified + # after this method is called; call {#reset_full_paths} to reset cache. + # @return [Array<String>] a list of full paths + # + # source://yard-0.9.28/lib/yard/templates/template.rb:65 + def full_paths; end + + # @return [Boolean] + # + # source://yard-0.9.28/lib/yard/templates/template.rb:122 + def is_a?(klass); end + + # Creates a new template object to be rendered with {Template#run} + # + # source://yard-0.9.28/lib/yard/templates/template.rb:128 + def new(*args); end + + # Returns the value of attribute path. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:60 + def path; end + + # Sets the attribute path + # + # @param value the value to set the attribute path to. + # + # source://yard-0.9.28/lib/yard/templates/template.rb:60 + def path=(_arg0); end + + # Resets cache for {#full_paths} + # + # source://yard-0.9.28/lib/yard/templates/template.rb:77 + def reset_full_paths; end + + # source://yard-0.9.28/lib/yard/templates/template.rb:135 + def run(*args); end + + private + + # source://yard-0.9.28/lib/yard/templates/template.rb:170 + def include_inherited(full_paths); end + + # source://yard-0.9.28/lib/yard/templates/template.rb:157 + def include_parent; end + + # source://yard-0.9.28/lib/yard/templates/template.rb:176 + def load_setup_rb; end +end + +# An Options class containing default options for base template rendering. For +# options specific to generation of HTML output, see {CLI::YardocOptions}. +# +# @see CLI::YardocOptions +# +# source://yard-0.9.28/lib/yard/templates/template_options.rb:11 +class YARD::Templates::TemplateOptions < ::YARD::Options + # @return [OpenStruct] an open struct containing any global state across all + # generated objects in a template. + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def __globals; end + + # @return [String] the default return type for a method with no return tags + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def default_return; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def default_return=(_arg0); end + + # @example A list of mixin path names (including wildcards) + # opts.embed_mixins #=> ['ClassMethods', '*Helper', 'YARD::*'] + # @return [Array<String>] an array of module name wildcards to embed into + # class documentation as if their methods were defined directly in the class. + # Useful for modules like ClassMethods. If the name contains '::', the module + # is matched against the full mixin path, otherwise only the module name is used. + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def embed_mixins; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def embed_mixins=(_arg0); end + + # @param mixin [CodeObjects::Base] accepts any code object, but returns + # nil unless the object is a module. + # @return [Boolean] whether a mixin matches the embed_mixins list + # @return [nil] if the mixin is not a module object + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:78 + def embed_mixins_match?(mixin); end + + # @return [Symbol] the template output format + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def format; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def format=(_arg0); end + + # @return [OpenStruct] an open struct containing any global state across all + # generated objects in a template. + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def globals; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def globals=(_arg0); end + + # @return [Boolean] whether void methods should show "void" in their signature + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def hide_void_return; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def hide_void_return=(_arg0); end + + # @return [Boolean] whether code blocks should be syntax highlighted + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def highlight; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def highlight=(_arg0); end + + # @return [Boolean] whether the page is the "index" + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:64 + def index; end + + # @return [Boolean] whether the page is the "index" + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:64 + def index=(_arg0); end + + # @return [Symbol] the markup format to use when parsing docstrings + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def markup; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def markup=(_arg0); end + + # @return [Class] the markup provider class for the markup format + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:30 + def markup_provider; end + + # @return [Class] the markup provider class for the markup format + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:30 + def markup_provider=(_arg0); end + + # @deprecated use {#highlight} instead. + # @return [Boolean] whether highlighting should be ignored + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:57 + def no_highlight; end + + # source://yard-0.9.28/lib/yard/templates/template_options.rb:58 + def no_highlight=(value); end + + # @return [CodeObjects::Base] the main object being generated in the template + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:38 + def object; end + + # @return [CodeObjects::Base] the main object being generated in the template + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:38 + def object=(_arg0); end + + # @return [CodeObjects::Base] the owner of the generated object + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:41 + def owner; end + + # @return [CodeObjects::Base] the owner of the generated object + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:41 + def owner=(_arg0); end + + # @return [String] the title of a given page + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:61 + def page_title; end + + # @return [String] the title of a given page + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:61 + def page_title=(_arg0); end + + # @return [Boolean] whether serialization should be performed + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def serialize; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def serialize=(_arg0); end + + # @return [Serializers::Base] the serializer used to generate links and serialize + # output. Serialization output only occurs if {#serialize} is +true+. + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:51 + def serializer; end + + # @return [Serializers::Base] the serializer used to generate links and serialize + # output. Serialization output only occurs if {#serialize} is +true+. + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:51 + def serializer=(_arg0); end + + # @return [Symbol] the template name used to render output + # + # source://yard-0.9.28/lib/yard/options.rb:82 + def template; end + + # source://yard-0.9.28/lib/yard/options.rb:82 + def template=(_arg0); end + + # @return [Symbol] the template type used to generate output + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:44 + def type; end + + # @return [Symbol] the template type used to generate output + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:44 + def type=(_arg0); end + + # @return [Verifier] the verifier object + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:89 + def verifier; end + + # @return [Verifier] the verifier object + # + # source://yard-0.9.28/lib/yard/templates/template_options.rb:89 + def verifier=(_arg0); end +end + +# source://yard-0.9.28/lib/yard/version.rb:5 +YARD::VERSION = T.let(T.unsafe(nil), String) + +# Similar to a Proc, but runs a set of Ruby expressions using a small +# DSL to make tag lookups easier. +# +# The syntax is as follows: +# * All syntax is Ruby compatible +# * +object+ (+o+ for short) exist to access the object being verified +# * +@TAGNAME+ is translated into +object.tag('TAGNAME')+ +# * +@@TAGNAME+ is translated into +object.tags('TAGNAME')+ +# * +object+ can be omitted as target for method calls (it is implied) +# +# @example Create a verifier to check for objects that don't have @private tags +# verifier = Verifier.new('!@private') +# verifier.call(object) # => true (no @private tag) +# @example Create a verifier to find any return tag with an empty description +# Verifier.new('@return.text.empty?') +# # Equivalent to: +# Verifier.new('object.tag(:return).text.empty?') +# @example Check if there are any @param tags +# Verifier.new('@@param.empty?') +# # Equivalent to: +# Verifier.new('object.tags(:param).empty?') +# @example Using +object+ or +o+ to look up object attributes directly +# Verifier.new('object.docstring == "hello world"') +# # Equivalent to: +# Verifier.new('o.docstring == "hello world"') +# @example Without using +object+ or +o+ +# Verifier.new('tag(:return).size == 1 || has_tag?(:author)') +# @example Specifying multiple expressions +# Verifier.new('@return', '@param', '@yield') +# # Equivalent to: +# Verifier.new('@return && @param && @yield') +# +# source://yard-0.9.28/lib/yard/verifier.rb:34 +class YARD::Verifier + # Creates a verifier from a set of expressions + # + # @param expressions [Array<String>] a list of Ruby expressions to + # parse. + # @return [Verifier] a new instance of Verifier + # + # source://yard-0.9.28/lib/yard/verifier.rb:48 + def initialize(*expressions); end + + # Adds a set of expressions and recompiles the verifier + # + # @param expressions [Array<String>] a list of expressions + # @return [void] + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/verifier.rb:58 + def add_expressions(*expressions); end + + # Tests the expressions on the object. + # + # @note If the object is a {CodeObjects::Proxy} the result will always be true. + # @param object [CodeObjects::Base] the object to verify + # @return [Boolean] the result of the expressions + # + # source://yard-0.9.28/lib/yard/verifier.rb:76 + def call(object); end + + # @return [Array<String>] a list of all expressions the verifier checks for + # @since 0.5.6 + # + # source://yard-0.9.28/lib/yard/verifier.rb:37 + def expressions; end + + # source://yard-0.9.28/lib/yard/verifier.rb:39 + def expressions=(value); end + + # Passes any method calls to the object from the {#call} + # + # source://yard-0.9.28/lib/yard/verifier.rb:63 + def method_missing(sym, *args, &block); end + + # Runs a list of objects against the verifier and returns the subset + # of verified objects. + # + # @param list [Array<CodeObjects::Base>] a list of code objects + # @return [Array<CodeObjects::Base>] a list of code objects that match + # the verifier. + # + # source://yard-0.9.28/lib/yard/verifier.rb:91 + def run(list); end + + protected + + # @return [CodeObjects::Base] the current object being tested + # + # source://yard-0.9.28/lib/yard/verifier.rb:98 + def o; end + + # @return [CodeObjects::Base] the current object being tested + # + # source://yard-0.9.28/lib/yard/verifier.rb:98 + def object; end + + private + + # Creates the +__execute+ method by evaluating the expressions + # as Ruby code + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/verifier.rb:130 + def create_method_from_expressions; end + + # Modifies nil to not throw NoMethodErrors. This allows + # syntax like object.tag(:return).text to work if the #tag + # call returns nil, which means users don't need to perform + # stringent nil checking + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/verifier.rb:112 + def modify_nilclass; end + + # Parses a single expression, handling some of the DSL syntax. + # + # The syntax "@tag" should be turned into object.tag(:tag), + # and "@@tag" should be turned into object.tags(:tag) + # + # @return [String] the parsed expression + # + # source://yard-0.9.28/lib/yard/verifier.rb:145 + def parse_expression(expr); end + + # Returns the state of NilClass back to normal + # + # @return [void] + # + # source://yard-0.9.28/lib/yard/verifier.rb:120 + def unmodify_nilclass; end +end + +# @private +# +# source://yard-0.9.28/lib/yard/verifier.rb:104 +YARD::Verifier::NILCLASS_METHODS = T.let(T.unsafe(nil), Array) diff --git a/sorbet/rbi/hidden-definitions/errors.txt b/sorbet/rbi/hidden-definitions/errors.txt deleted file mode 100644 index 29fee9f4..00000000 --- a/sorbet/rbi/hidden-definitions/errors.txt +++ /dev/null @@ -1,8293 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi hidden-definitions - -# typed: autogenerated - -# wrong constant name <DeclBuilderForProcs> -# wrong constant name <DeclBuilderForProcs> -# wrong constant name <Class:<DeclBuilderForProcs>> -# wrong constant name <Magic> -# wrong constant name <Magic> -# wrong constant name <Class:<Magic>> -# wrong constant name <PackageSpecRegistry> -# wrong constant name <PackageSpecRegistry> -# wrong constant name <RESERVED_0> -# wrong constant name <RESERVED_1> -# wrong constant name <RESERVED_2> -# wrong constant name <RESERVED_3> -# wrong constant name <RESERVED_4> -# wrong constant name <RESERVED_5> -# wrong constant name <TypeAlias> -# wrong constant name <TypeAlias> -# wrong constant name <root> -# wrong constant name <Class:<root>> -# wrong constant name <todo sym> -# wrong constant name <todo sym> -# wrong constant name <top> -# wrong constant name <top> -# wrong constant name connect_internal -# wrong constant name abbrev -# wrong constant name deconstruct -# wrong constant name shelljoin -# wrong constant name to_h -# wrong constant name try_convert -# wrong constant name <Class:BasicObject> -# uninitialized constant Benchmark -# uninitialized constant Benchmark -# wrong constant name clone -# wrong constant name interpret_loosely -# wrong constant name clone -# wrong constant name irb -# uninitialized constant Bundler::Dependency::TYPES -# wrong constant name branch -# wrong constant name expanded_platforms -# wrong constant name git -# wrong constant name <static-init> -# wrong constant name environment -# wrong constant name report -# wrong constant name write -# wrong constant name <Class:Base> -# wrong constant name <Class:CompactIndex> -# wrong constant name <Class:Dependency> -# wrong constant name <Class:Downloader> -# wrong constant name <Class:Index> -# wrong constant name <Class:TooManyRequestsError> -# wrong constant name fetch_spec -# wrong constant name fetchers -# wrong constant name http_proxy -# wrong constant name initialize -# wrong constant name specs -# wrong constant name specs_with_retry -# wrong constant name uri -# wrong constant name use_api -# wrong constant name user_agent -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name api_fetcher? -# wrong constant name available? -# wrong constant name display_uri -# wrong constant name downloader -# wrong constant name fetch_uri -# wrong constant name initialize -# wrong constant name remote -# wrong constant name remote_uri -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name <Class:ClientFetcher> -# wrong constant name available? -# wrong constant name fetch_spec -# wrong constant name specs -# wrong constant name specs_for_names -# uninitialized constant Bundler::Fetcher::CompactIndex::ClientFetcher::Elem -# wrong constant name call -# wrong constant name fetcher -# wrong constant name fetcher= -# wrong constant name ui -# wrong constant name ui= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# wrong constant name compact_index_request -# wrong constant name dependency_api_uri -# wrong constant name dependency_specs -# wrong constant name get_formatted_specs_and_deps -# wrong constant name specs -# wrong constant name unmarshalled_dep_gems -# wrong constant name <static-init> -# wrong constant name connection -# wrong constant name fetch -# wrong constant name initialize -# wrong constant name redirect_limit -# wrong constant name request -# wrong constant name <static-init> -# wrong constant name fetch_spec -# wrong constant name specs -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name api_timeout -# wrong constant name api_timeout= -# wrong constant name disable_endpoint -# wrong constant name disable_endpoint= -# wrong constant name max_retries -# wrong constant name max_retries= -# wrong constant name redirect_limit -# wrong constant name redirect_limit= -# wrong constant name link -# wrong constant name cp_lr -# wrong constant name link_entry -# uninitialized constant Bundler::GemHelper::DEFAULT -# uninitialized constant Bundler::GemHelper::LN_SUPPORTED -# uninitialized constant Bundler::GemHelper::LOW_METHODS -# Did you mean? Bundler::GemHelper::LowMethods -# uninitialized constant Bundler::GemHelper::METHODS -# Did you mean? Method -# uninitialized constant Bundler::GemHelper::OPT_TABLE -# uninitialized constant Bundler::GemHelper::RUBY -# uninitialized constant Bundler::GemHelper::VERSION -# Did you mean? Bundler::VERSION -# wrong constant name allowed_push_host -# wrong constant name already_tagged? -# wrong constant name base -# wrong constant name build_gem -# wrong constant name built_gem_path -# wrong constant name clean? -# wrong constant name committed? -# wrong constant name gem_command -# wrong constant name gem_key -# wrong constant name gem_push? -# wrong constant name gem_push_host -# wrong constant name gemspec -# wrong constant name git_push -# wrong constant name guard_clean -# wrong constant name initialize -# wrong constant name install -# wrong constant name install_gem -# wrong constant name name -# wrong constant name perform_git_push -# wrong constant name rubygem_push -# wrong constant name sh -# wrong constant name sh_with_input -# wrong constant name sh_with_status -# wrong constant name spec_path -# wrong constant name tag_version -# wrong constant name version -# wrong constant name version_tag -# wrong constant name <static-init> -# wrong constant name gemspec -# wrong constant name install_tasks -# wrong constant name instance -# wrong constant name instance= -# wrong constant name initialize -# wrong constant name level -# wrong constant name level= -# wrong constant name locked_specs -# wrong constant name major? -# wrong constant name minor? -# wrong constant name prerelease_specified -# wrong constant name prerelease_specified= -# wrong constant name sort_versions -# wrong constant name strict -# wrong constant name strict= -# wrong constant name unlock_gems -# wrong constant name <static-init> -# wrong constant name <Class:GraphVizClient> -# wrong constant name edge_options -# wrong constant name groups -# wrong constant name initialize -# wrong constant name node_options -# wrong constant name output_file -# wrong constant name output_format -# wrong constant name relations -# wrong constant name viz -# wrong constant name g -# wrong constant name initialize -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name inject -# wrong constant name remove -# wrong constant name <static-init> -# wrong constant name inject -# wrong constant name remove -# wrong constant name _recursive_predecessors -# wrong constant name _recursive_successors -# wrong constant name == -# wrong constant name app_cache_dirname -# wrong constant name app_cache_path -# wrong constant name bundler_plugin_api_source? -# wrong constant name cache -# wrong constant name cached! -# wrong constant name can_lock? -# wrong constant name dependency_names -# wrong constant name dependency_names= -# wrong constant name double_check_for -# wrong constant name eql? -# wrong constant name fetch_gemspec_files -# wrong constant name gem_install_dir -# wrong constant name hash -# wrong constant name include? -# wrong constant name initialize -# wrong constant name install -# wrong constant name install_path -# wrong constant name installed? -# wrong constant name name -# wrong constant name options -# wrong constant name options_to_lock -# wrong constant name post_install -# wrong constant name remote! -# wrong constant name root -# wrong constant name specs -# wrong constant name to_lock -# wrong constant name to_s -# wrong constant name unlock! -# wrong constant name unmet_deps -# wrong constant name uri -# wrong constant name uri_hash -# wrong constant name <static-init> -# wrong constant name <Class:CommandConflict> -# wrong constant name <Class:SourceConflict> -# wrong constant name installed_plugins -# wrong constant name plugin_commands -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <Class:Git> -# wrong constant name <Class:Rubygems> -# wrong constant name install -# wrong constant name install_definition -# uninitialized constant Bundler::Plugin::Installer::Git::DEFAULT_GLOB -# wrong constant name generate_bin -# wrong constant name <static-init> -# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT -# Did you mean? Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE -# uninitialized constant Bundler::Plugin::Installer::Rubygems::API_REQUEST_SIZE -# Did you mean? Bundler::Plugin::Installer::Rubygems::API_REQUEST_LIMIT -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name list -# wrong constant name <static-init> -# wrong constant name lock -# wrong constant name attempt -# wrong constant name attempts -# wrong constant name current_run -# wrong constant name current_run= -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name total_runs -# wrong constant name total_runs= -# wrong constant name <static-init> -# wrong constant name attempts -# wrong constant name default_attempts -# wrong constant name default_retries -# uninitialized constant Bundler::RubyGemsGemInstaller::ENV_PATHS -# wrong constant name <static-init> -# wrong constant name add_to_load_path -# wrong constant name all_specs -# wrong constant name backport_ext_builder_monitor -# wrong constant name correct_for_windows_path -# wrong constant name default_stubs -# wrong constant name find_name -# wrong constant name gem_remote_fetcher -# wrong constant name plain_specs -# wrong constant name plain_specs= -# wrong constant name stub_rubygems -# wrong constant name use_gemdeps -# uninitialized constant Bundler::RubygemsIntegration::AlmostModern -# uninitialized constant Bundler::RubygemsIntegration::AlmostModern -# uninitialized constant Bundler::RubygemsIntegration::Ancient -# uninitialized constant Bundler::RubygemsIntegration::Ancient -# uninitialized constant Bundler::RubygemsIntegration::Future -# uninitialized constant Bundler::RubygemsIntegration::Future -# uninitialized constant Bundler::RubygemsIntegration::Legacy -# uninitialized constant Bundler::RubygemsIntegration::Legacy -# uninitialized constant Bundler::RubygemsIntegration::Modern -# Did you mean? Module -# uninitialized constant Bundler::RubygemsIntegration::Modern -# Did you mean? Module -# uninitialized constant Bundler::RubygemsIntegration::MoreFuture -# uninitialized constant Bundler::RubygemsIntegration::MoreFuture -# uninitialized constant Bundler::RubygemsIntegration::MoreModern -# uninitialized constant Bundler::RubygemsIntegration::MoreModern -# uninitialized constant Bundler::RubygemsIntegration::Transitional -# uninitialized constant Bundler::RubygemsIntegration::Transitional -# wrong constant name == -# wrong constant name fallback_timeout -# wrong constant name fallback_timeout= -# wrong constant name initialize -# wrong constant name uri -# wrong constant name uri= -# wrong constant name valid? -# wrong constant name validate! -# wrong constant name <static-init> -# wrong constant name each -# wrong constant name for -# wrong constant name initialize -# wrong constant name parse -# wrong constant name <static-init> -# wrong constant name <Class:Rule> -# wrong constant name description -# wrong constant name fail! -# wrong constant name initialize -# wrong constant name k -# wrong constant name set -# wrong constant name validate! -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name validate! -# uninitialized constant Bundler::Source::Git::DEFAULT_GLOB -# wrong constant name glob -# wrong constant name <Class:Actions> -# wrong constant name <Class:AmbiguousCommandError> -# wrong constant name <Class:Argument> -# wrong constant name <Class:Arguments> -# wrong constant name <Class:Base> -# wrong constant name <Class:Command> -# wrong constant name <Class:CoreExt> -# wrong constant name <Class:DynamicCommand> -# wrong constant name <Class:Error> -# wrong constant name <Class:Group> -# wrong constant name <Class:HiddenCommand> -# wrong constant name <Class:Invocation> -# wrong constant name <Class:InvocationError> -# wrong constant name <Class:LineEditor> -# wrong constant name <Class:MalformattedArgumentError> -# wrong constant name <Class:NestedContext> -# wrong constant name <Class:NoKwargSpellChecker> -# wrong constant name <Class:Option> -# wrong constant name <Class:Options> -# wrong constant name <Class:RakeCompat> -# wrong constant name <Class:RequiredArgumentMissingError> -# uninitialized constant Bundler::Thor::SHELL_DELEGATED_METHODS -# wrong constant name <Class:Sandbox> -# wrong constant name <Class:Shell> -# wrong constant name <Class:UndefinedCommandError> -# wrong constant name <Class:UnknownArgumentError> -# wrong constant name <Class:Util> -# wrong constant name help -# wrong constant name <Class:CapturableERB> -# wrong constant name <Class:ClassMethods> -# wrong constant name <Class:CreateFile> -# wrong constant name <Class:CreateLink> -# wrong constant name <Class:Directory> -# wrong constant name <Class:EmptyDirectory> -# wrong constant name <Class:InjectIntoFile> -# wrong constant name _cleanup_options_and_set -# wrong constant name _shared_configuration -# wrong constant name action -# wrong constant name add_file -# wrong constant name add_link -# wrong constant name append_file -# wrong constant name append_to_file -# wrong constant name apply -# wrong constant name behavior -# wrong constant name behavior= -# wrong constant name chmod -# wrong constant name comment_lines -# wrong constant name copy_file -# wrong constant name create_file -# wrong constant name create_link -# wrong constant name destination_root -# wrong constant name destination_root= -# wrong constant name directory -# wrong constant name empty_directory -# wrong constant name find_in_source_paths -# wrong constant name get -# wrong constant name gsub_file -# wrong constant name in_root -# wrong constant name initialize -# wrong constant name inject_into_class -# wrong constant name inject_into_file -# wrong constant name inject_into_module -# wrong constant name insert_into_file -# wrong constant name inside -# wrong constant name link_file -# wrong constant name prepend_file -# wrong constant name prepend_to_file -# wrong constant name relative_to_original_destination_root -# wrong constant name remove_dir -# wrong constant name remove_file -# wrong constant name run -# wrong constant name run_ruby_script -# wrong constant name source_paths -# wrong constant name template -# wrong constant name thor -# wrong constant name uncomment_lines -# uninitialized constant Bundler::Thor::Actions::CapturableERB::Revision -# wrong constant name <static-init> -# wrong constant name add_runtime_options! -# wrong constant name source_paths -# wrong constant name source_paths_for_search -# wrong constant name source_root -# wrong constant name <static-init> -# wrong constant name data -# wrong constant name force_on_collision? -# wrong constant name force_or_skip_or_conflict -# wrong constant name identical? -# wrong constant name initialize -# wrong constant name on_conflict_behavior -# wrong constant name render -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name execute! -# wrong constant name file_level_lookup -# wrong constant name files -# wrong constant name initialize -# wrong constant name source -# wrong constant name <static-init> -# wrong constant name base -# wrong constant name config -# wrong constant name convert_encoded_instructions -# wrong constant name destination -# wrong constant name destination= -# wrong constant name exists? -# wrong constant name given_destination -# wrong constant name initialize -# wrong constant name invoke! -# wrong constant name invoke_with_conflict_check -# wrong constant name on_conflict_behavior -# wrong constant name on_file_clash_behavior -# wrong constant name pretend? -# wrong constant name relative_destination -# wrong constant name revoke! -# wrong constant name say_status -# wrong constant name <static-init> -# wrong constant name behavior -# wrong constant name flag -# wrong constant name initialize -# wrong constant name replace! -# wrong constant name replacement -# wrong constant name say_status -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name included -# wrong constant name <static-init> -# wrong constant name banner -# wrong constant name default -# wrong constant name default_banner -# wrong constant name description -# wrong constant name enum -# wrong constant name human_name -# wrong constant name initialize -# wrong constant name name -# wrong constant name required -# wrong constant name required? -# wrong constant name show_default? -# wrong constant name type -# wrong constant name usage -# wrong constant name valid_type? -# wrong constant name validate! -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name parse -# wrong constant name remaining -# wrong constant name <static-init> -# wrong constant name parse -# wrong constant name split -# wrong constant name <Class:ClassMethods> -# wrong constant name args -# wrong constant name args= -# wrong constant name initialize -# wrong constant name options -# wrong constant name options= -# wrong constant name parent_options -# wrong constant name parent_options= -# wrong constant name all_commands -# wrong constant name all_tasks -# wrong constant name allow_incompatible_default_type! -# wrong constant name argument -# wrong constant name arguments -# wrong constant name attr_accessor -# wrong constant name attr_reader -# wrong constant name attr_writer -# wrong constant name baseclass -# wrong constant name basename -# wrong constant name build_option -# wrong constant name build_options -# wrong constant name check_default_type -# wrong constant name check_default_type! -# wrong constant name check_unknown_options -# wrong constant name check_unknown_options! -# wrong constant name check_unknown_options? -# wrong constant name class_option -# wrong constant name class_options -# wrong constant name class_options_help -# wrong constant name commands -# wrong constant name create_command -# wrong constant name create_task -# wrong constant name disable_required_check? -# wrong constant name dispatch -# wrong constant name exit_on_failure? -# wrong constant name find_and_refresh_command -# wrong constant name find_and_refresh_task -# wrong constant name from_superclass -# wrong constant name group -# wrong constant name handle_argument_error -# wrong constant name handle_no_command_error -# wrong constant name handle_no_task_error -# wrong constant name inherited -# wrong constant name initialize_added -# wrong constant name is_thor_reserved_word? -# wrong constant name method_added -# wrong constant name namespace -# wrong constant name no_commands -# wrong constant name no_commands? -# wrong constant name no_commands_context -# wrong constant name no_tasks -# wrong constant name print_options -# wrong constant name public_command -# wrong constant name public_task -# wrong constant name remove_argument -# wrong constant name remove_class_option -# wrong constant name remove_command -# wrong constant name remove_task -# wrong constant name start -# wrong constant name stop_on_unknown_option? -# wrong constant name strict_args_position -# wrong constant name strict_args_position! -# wrong constant name strict_args_position? -# wrong constant name tasks -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name included -# wrong constant name register_klass_file -# wrong constant name shell -# wrong constant name shell= -# wrong constant name subclass_files -# wrong constant name subclasses -# wrong constant name formatted_usage -# wrong constant name handle_argument_error? -# wrong constant name handle_no_method_error? -# wrong constant name hidden? -# wrong constant name initialize -# wrong constant name local_method? -# wrong constant name not_debugging? -# wrong constant name private_method? -# wrong constant name public_method? -# wrong constant name required_arguments_for -# wrong constant name required_options -# wrong constant name run -# wrong constant name sans_backtrace -# wrong constant name <static-init> -# wrong constant name <Class:HashWithIndifferentAccess> -# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::Elem -# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::K -# uninitialized constant Bundler::Thor::CoreExt::HashWithIndifferentAccess::V -# wrong constant name [] -# wrong constant name []= -# wrong constant name convert_key -# wrong constant name delete -# wrong constant name fetch -# wrong constant name initialize -# wrong constant name key? -# wrong constant name merge -# wrong constant name merge! -# wrong constant name method_missing -# wrong constant name replace -# wrong constant name reverse_merge -# wrong constant name reverse_merge! -# wrong constant name values_at -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant Bundler::Thor::DynamicCommand::FILE_REGEXP -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant Bundler::Thor::Group::SHELL_DELEGATED_METHODS -# Did you mean? Bundler::Thor::SHELL_DELEGATED_METHODS -# wrong constant name _invoke_for_class_method -# wrong constant name <static-init> -# wrong constant name banner -# wrong constant name desc -# wrong constant name get_options_from_invocations -# wrong constant name handle_argument_error -# wrong constant name help -# wrong constant name invocation_blocks -# wrong constant name invocations -# wrong constant name invoke -# wrong constant name invoke_from_option -# wrong constant name printable_commands -# wrong constant name printable_tasks -# wrong constant name remove_invocation -# wrong constant name self_command -# wrong constant name self_task -# uninitialized constant Bundler::Thor::HiddenCommand::FILE_REGEXP -# wrong constant name <static-init> -# wrong constant name <Class:ClassMethods> -# wrong constant name _parse_initialization_options -# wrong constant name _retrieve_class_and_command -# wrong constant name _retrieve_class_and_task -# wrong constant name _shared_configuration -# wrong constant name current_command_chain -# wrong constant name initialize -# wrong constant name invoke -# wrong constant name invoke_all -# wrong constant name invoke_command -# wrong constant name invoke_task -# wrong constant name invoke_with_padding -# wrong constant name prepare_for_invocation -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name included -# wrong constant name <static-init> -# wrong constant name <Class:Basic> -# wrong constant name <Class:Readline> -# wrong constant name initialize -# wrong constant name options -# wrong constant name prompt -# wrong constant name readline -# wrong constant name <static-init> -# wrong constant name available? -# wrong constant name <Class:PathCompletion> -# wrong constant name initialize -# wrong constant name matches -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name best_available -# wrong constant name readline -# wrong constant name <static-init> -# wrong constant name enter -# wrong constant name entered? -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name aliases -# wrong constant name array? -# wrong constant name boolean? -# wrong constant name dasherize -# wrong constant name dasherized? -# wrong constant name group -# wrong constant name hash? -# wrong constant name hide -# wrong constant name lazy_default -# wrong constant name numeric? -# wrong constant name repeatable -# wrong constant name string? -# wrong constant name switch_name -# wrong constant name undasherize -# wrong constant name usage -# wrong constant name validate_default_type! -# wrong constant name <static-init> -# wrong constant name parse -# uninitialized constant Bundler::Thor::Options::NUMERIC -# Did you mean? Numeric -# wrong constant name assign_result! -# wrong constant name check_unknown! -# wrong constant name current_is_switch? -# wrong constant name current_is_switch_formatted? -# wrong constant name initialize -# wrong constant name normalize_switch -# wrong constant name parse_boolean -# wrong constant name parse_peek -# wrong constant name parsing_options? -# wrong constant name switch? -# wrong constant name switch_option -# wrong constant name <static-init> -# wrong constant name to_switches -# uninitialized constant Bundler::Thor::RakeCompat::DEFAULT -# uninitialized constant Bundler::Thor::RakeCompat::LN_SUPPORTED -# uninitialized constant Bundler::Thor::RakeCompat::LOW_METHODS -# Did you mean? Bundler::Thor::RakeCompat::LowMethods -# uninitialized constant Bundler::Thor::RakeCompat::METHODS -# Did you mean? Method -# uninitialized constant Bundler::Thor::RakeCompat::OPT_TABLE -# uninitialized constant Bundler::Thor::RakeCompat::RUBY -# uninitialized constant Bundler::Thor::RakeCompat::VERSION -# Did you mean? Bundler::VERSION -# wrong constant name <static-init> -# wrong constant name included -# wrong constant name rake_classes -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <Class:Basic> -# wrong constant name <Class:Color> -# wrong constant name <Class:HTML> -# wrong constant name _shared_configuration -# wrong constant name ask -# wrong constant name error -# wrong constant name file_collision -# wrong constant name initialize -# wrong constant name no? -# wrong constant name print_in_columns -# wrong constant name print_table -# wrong constant name print_wrapped -# wrong constant name say -# wrong constant name say_status -# wrong constant name set_color -# wrong constant name shell -# wrong constant name shell= -# wrong constant name terminal_width -# wrong constant name with_padding -# wrong constant name yes? -# wrong constant name answer_match -# wrong constant name as_unicode -# wrong constant name ask -# wrong constant name ask_filtered -# wrong constant name ask_simply -# wrong constant name base -# wrong constant name base= -# wrong constant name can_display_colors? -# wrong constant name dynamic_width -# wrong constant name dynamic_width_stty -# wrong constant name dynamic_width_tput -# wrong constant name error -# wrong constant name file_collision -# wrong constant name file_collision_help -# wrong constant name git_merge_tool -# wrong constant name indent -# wrong constant name is? -# wrong constant name lookup_color -# wrong constant name merge -# wrong constant name merge_tool -# wrong constant name mute -# wrong constant name mute? -# wrong constant name no? -# wrong constant name padding -# wrong constant name padding= -# wrong constant name prepare_message -# wrong constant name print_in_columns -# wrong constant name print_table -# wrong constant name print_wrapped -# wrong constant name quiet? -# wrong constant name say -# wrong constant name say_status -# wrong constant name set_color -# wrong constant name show_diff -# wrong constant name stderr -# wrong constant name stdout -# wrong constant name terminal_width -# wrong constant name truncate -# wrong constant name unix? -# wrong constant name yes? -# wrong constant name <static-init> -# uninitialized constant Bundler::Thor::Shell::Color::DEFAULT_TERMINAL_WIDTH -# wrong constant name are_colors_disabled? -# wrong constant name diff_lcs_loaded? -# wrong constant name output_diff_line -# wrong constant name set_color -# wrong constant name <static-init> -# uninitialized constant Bundler::Thor::Shell::HTML::DEFAULT_TERMINAL_WIDTH -# wrong constant name ask -# wrong constant name diff_lcs_loaded? -# wrong constant name output_diff_line -# wrong constant name set_color -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <Class:SpellChecker> -# wrong constant name all_commands -# wrong constant name command -# wrong constant name initialize -# wrong constant name corrections -# wrong constant name error -# wrong constant name initialize -# wrong constant name spell_checker -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <Class:SpellChecker> -# wrong constant name initialize -# wrong constant name switches -# wrong constant name unknown -# wrong constant name corrections -# wrong constant name error -# wrong constant name initialize -# wrong constant name spell_checker -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name camel_case -# wrong constant name escape_globs -# wrong constant name escape_html -# wrong constant name find_by_namespace -# wrong constant name find_class_and_command_by_namespace -# wrong constant name find_class_and_task_by_namespace -# wrong constant name globs_for -# wrong constant name load_thorfile -# wrong constant name namespace_from_thor_class -# wrong constant name namespaces_in_content -# wrong constant name ruby_command -# wrong constant name snake_case -# wrong constant name thor_classes_in -# wrong constant name thor_root -# wrong constant name thor_root_glob -# wrong constant name user_home -# wrong constant name <static-init> -# wrong constant name banner -# wrong constant name check_unknown_options! -# wrong constant name command_help -# wrong constant name default_command -# wrong constant name default_task -# wrong constant name deprecation_warning -# wrong constant name desc -# wrong constant name disable_required_check -# wrong constant name disable_required_check! -# wrong constant name disable_required_check? -# wrong constant name dispatch -# wrong constant name dynamic_command_class -# wrong constant name find_command_possibilities -# wrong constant name find_task_possibilities -# wrong constant name help -# wrong constant name long_desc -# wrong constant name map -# wrong constant name method_option -# wrong constant name method_options -# wrong constant name normalize_command_name -# wrong constant name normalize_task_name -# wrong constant name option -# wrong constant name options -# wrong constant name package_name -# wrong constant name printable_commands -# wrong constant name printable_tasks -# wrong constant name register -# wrong constant name retrieve_command_name -# wrong constant name retrieve_task_name -# wrong constant name stop_on_unknown_option -# wrong constant name stop_on_unknown_option! -# wrong constant name stop_on_unknown_option? -# wrong constant name subcommand -# wrong constant name subcommand_classes -# wrong constant name subcommand_help -# wrong constant name subcommands -# wrong constant name subtask -# wrong constant name subtask_help -# wrong constant name subtasks -# wrong constant name task_help -# wrong constant name add_color -# wrong constant name ask -# wrong constant name confirm -# wrong constant name debug -# wrong constant name debug? -# wrong constant name error -# wrong constant name info -# wrong constant name initialize -# wrong constant name level -# wrong constant name level= -# wrong constant name no? -# wrong constant name quiet? -# wrong constant name shell= -# wrong constant name silence -# wrong constant name trace -# wrong constant name unprinted_warnings -# wrong constant name warn -# wrong constant name yes? -# wrong constant name <static-init> -# wrong constant name <Class:BadURIError> -# wrong constant name <Class:Error> -# wrong constant name <Class:Escape> -# wrong constant name <Class:FTP> -# wrong constant name <Class:File> -# wrong constant name <Class:Generic> -# wrong constant name <Class:HTTP> -# wrong constant name <Class:HTTPS> -# wrong constant name <Class:InvalidComponentError> -# wrong constant name <Class:InvalidURIError> -# wrong constant name <Class:LDAP> -# wrong constant name <Class:LDAPS> -# wrong constant name <Class:MailTo> -# wrong constant name <Class:RFC2396_Parser> -# wrong constant name <Class:RFC2396_REGEXP> -# wrong constant name <Class:RFC3986_Parser> -# wrong constant name <Class:Util> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name decode -# wrong constant name encode -# wrong constant name escape -# wrong constant name unescape -# wrong constant name <static-init> -# uninitialized constant Bundler::URI::FTP::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::FTP::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::FTP::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::FTP::DEFAULT_PARSER -# Did you mean? Bundler::URI::FTP::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::FTP::ESCAPED -# Did you mean? Bundler::URI::FTP::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::FTP::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::FTP::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::FTP::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::FTP::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::FTP::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::FTP::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::FTP::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::FTP::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::FTP::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::FTP::RFC3986_PARSER -# Did you mean? Bundler::URI::FTP::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::FTP::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::FTP::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::FTP::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::FTP::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::FTP::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::FTP::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::FTP::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::FTP::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::FTP::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::FTP::USE_REGISTRY -# uninitialized constant Bundler::URI::FTP::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::FTP::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::FTP::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name set_typecode -# wrong constant name typecode -# wrong constant name typecode= -# wrong constant name <static-init> -# wrong constant name new2 -# uninitialized constant Bundler::URI::File::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::File::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::File::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::File::DEFAULT_PARSER -# Did you mean? Bundler::URI::File::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::File::ESCAPED -# Did you mean? Bundler::URI::File::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::File::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::File::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::File::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::File::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::File::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::File::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::File::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::File::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::File::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::File::RFC3986_PARSER -# Did you mean? Bundler::URI::File::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::File::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::File::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::File::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::File::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::File::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::File::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::File::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::File::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::File::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::File::USE_REGISTRY -# uninitialized constant Bundler::URI::File::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::File::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::File::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name check_password -# wrong constant name check_user -# wrong constant name check_userinfo -# wrong constant name set_userinfo -# wrong constant name <static-init> -# wrong constant name + -# wrong constant name - -# wrong constant name == -# uninitialized constant Bundler::URI::Generic::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::Generic::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::Generic::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::Generic::DEFAULT_PARSER -# Did you mean? Bundler::URI::Generic::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::Generic::ESCAPED -# Did you mean? Bundler::URI::Generic::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::Generic::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::Generic::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::Generic::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::Generic::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::Generic::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::Generic::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::Generic::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::Generic::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::Generic::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::Generic::RFC3986_PARSER -# Did you mean? Bundler::URI::Generic::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::Generic::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::Generic::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::Generic::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::Generic::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::Generic::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::Generic::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::Generic::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::Generic::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::Generic::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::Generic::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::Generic::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::Generic::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name absolute -# wrong constant name absolute? -# wrong constant name coerce -# wrong constant name component -# wrong constant name component_ary -# wrong constant name default_port -# wrong constant name eql? -# wrong constant name find_proxy -# wrong constant name fragment -# wrong constant name fragment= -# wrong constant name hierarchical? -# wrong constant name host -# wrong constant name host= -# wrong constant name hostname -# wrong constant name hostname= -# wrong constant name initialize -# wrong constant name merge -# wrong constant name merge! -# wrong constant name normalize -# wrong constant name normalize! -# wrong constant name opaque -# wrong constant name opaque= -# wrong constant name parser -# wrong constant name password -# wrong constant name password= -# wrong constant name path -# wrong constant name path= -# wrong constant name port -# wrong constant name port= -# wrong constant name query -# wrong constant name query= -# wrong constant name registry -# wrong constant name registry= -# wrong constant name relative? -# wrong constant name route_from -# wrong constant name route_to -# wrong constant name scheme -# wrong constant name scheme= -# wrong constant name select -# wrong constant name set_host -# wrong constant name set_opaque -# wrong constant name set_password -# wrong constant name set_path -# wrong constant name set_port -# wrong constant name set_registry -# wrong constant name set_scheme -# wrong constant name set_user -# wrong constant name set_userinfo -# wrong constant name user -# wrong constant name user= -# wrong constant name userinfo -# wrong constant name userinfo= -# wrong constant name <static-init> -# wrong constant name build -# wrong constant name build2 -# wrong constant name component -# wrong constant name default_port -# wrong constant name use_proxy? -# wrong constant name use_registry -# uninitialized constant Bundler::URI::HTTP::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::HTTP::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::HTTP::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::HTTP::DEFAULT_PARSER -# Did you mean? Bundler::URI::HTTP::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::HTTP::ESCAPED -# Did you mean? Bundler::URI::HTTP::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::HTTP::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::HTTP::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::HTTP::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::HTTP::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::HTTP::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::HTTP::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::HTTP::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::HTTP::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::HTTP::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::HTTP::RFC3986_PARSER -# Did you mean? Bundler::URI::HTTP::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::HTTP::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::HTTP::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::HTTP::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::HTTP::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::HTTP::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::HTTP::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::HTTP::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::HTTP::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::HTTP::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::HTTP::USE_REGISTRY -# uninitialized constant Bundler::URI::HTTP::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::HTTP::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::HTTP::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name request_uri -# wrong constant name <static-init> -# uninitialized constant Bundler::URI::HTTPS::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::HTTPS::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::HTTPS::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::HTTPS::COMPONENT -# uninitialized constant Bundler::URI::HTTPS::DEFAULT_PARSER -# Did you mean? Bundler::URI::HTTPS::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::HTTPS::ESCAPED -# Did you mean? Bundler::URI::HTTPS::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::HTTPS::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::HTTPS::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::HTTPS::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::HTTPS::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::HTTPS::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::HTTPS::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::HTTPS::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::HTTPS::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::HTTPS::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::HTTPS::RFC3986_PARSER -# Did you mean? Bundler::URI::HTTPS::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::HTTPS::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::HTTPS::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::HTTPS::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::HTTPS::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::HTTPS::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::HTTPS::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::HTTPS::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::HTTPS::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::HTTPS::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::HTTPS::USE_REGISTRY -# uninitialized constant Bundler::URI::HTTPS::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::HTTPS::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::HTTPS::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant Bundler::URI::LDAP::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::LDAP::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::LDAP::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::LDAP::DEFAULT_PARSER -# Did you mean? Bundler::URI::LDAP::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::LDAP::ESCAPED -# Did you mean? Bundler::URI::LDAP::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::LDAP::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::LDAP::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::LDAP::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::LDAP::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::LDAP::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::LDAP::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::LDAP::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::LDAP::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::LDAP::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::LDAP::RFC3986_PARSER -# Did you mean? Bundler::URI::LDAP::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::LDAP::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::LDAP::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::LDAP::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::LDAP::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::LDAP::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::LDAP::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::LDAP::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::LDAP::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::LDAP::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::LDAP::USE_REGISTRY -# uninitialized constant Bundler::URI::LDAP::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::LDAP::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::LDAP::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name attributes -# wrong constant name attributes= -# wrong constant name dn -# wrong constant name dn= -# wrong constant name extensions -# wrong constant name extensions= -# wrong constant name filter -# wrong constant name filter= -# wrong constant name initialize -# wrong constant name scope -# wrong constant name scope= -# wrong constant name set_attributes -# wrong constant name set_dn -# wrong constant name set_extensions -# wrong constant name set_filter -# wrong constant name set_scope -# wrong constant name <static-init> -# uninitialized constant Bundler::URI::LDAPS::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::LDAPS::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::LDAPS::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::LDAPS::COMPONENT -# uninitialized constant Bundler::URI::LDAPS::DEFAULT_PARSER -# Did you mean? Bundler::URI::LDAPS::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::LDAPS::ESCAPED -# Did you mean? Bundler::URI::LDAPS::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::LDAPS::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::LDAPS::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::LDAPS::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::LDAPS::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::LDAPS::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::LDAPS::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::LDAPS::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::LDAPS::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::LDAPS::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::LDAPS::RFC3986_PARSER -# Did you mean? Bundler::URI::LDAPS::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::LDAPS::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::LDAPS::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::LDAPS::SCOPE -# uninitialized constant Bundler::URI::LDAPS::SCOPE_BASE -# Did you mean? Bundler::URI::LDAPS::SCOPE_ONE -# uninitialized constant Bundler::URI::LDAPS::SCOPE_ONE -# Did you mean? Bundler::URI::LDAPS::SCOPE_SUB -# Bundler::URI::LDAPS::SCOPE_BASE -# uninitialized constant Bundler::URI::LDAPS::SCOPE_SUB -# Did you mean? Bundler::URI::LDAPS::SCOPE_ONE -# uninitialized constant Bundler::URI::LDAPS::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::LDAPS::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::LDAPS::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::LDAPS::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::LDAPS::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::LDAPS::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::LDAPS::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::LDAPS::USE_REGISTRY -# uninitialized constant Bundler::URI::LDAPS::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::LDAPS::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::LDAPS::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name <static-init> -# uninitialized constant Bundler::URI::MailTo::ABS_PATH -# Did you mean? Bundler::URI::ABS_PATH -# uninitialized constant Bundler::URI::MailTo::ABS_URI -# Did you mean? Bundler::URI::ABS_URI -# uninitialized constant Bundler::URI::MailTo::ABS_URI_REF -# Did you mean? Bundler::URI::ABS_URI_REF -# uninitialized constant Bundler::URI::MailTo::DEFAULT_PARSER -# Did you mean? Bundler::URI::MailTo::DEFAULT_PORT -# Bundler::URI::DEFAULT_PARSER -# uninitialized constant Bundler::URI::MailTo::ESCAPED -# Did you mean? Bundler::URI::MailTo::Escape -# Bundler::URI::Escape -# Bundler::URI::ESCAPED -# uninitialized constant Bundler::URI::MailTo::FRAGMENT -# Did you mean? Bundler::URI::FRAGMENT -# uninitialized constant Bundler::URI::MailTo::HOST -# Did you mean? Bundler::URI::HOST -# uninitialized constant Bundler::URI::MailTo::OPAQUE -# Did you mean? Bundler::URI::OPAQUE -# uninitialized constant Bundler::URI::MailTo::PORT -# Did you mean? Bundler::URI::PORT -# uninitialized constant Bundler::URI::MailTo::QUERY -# Did you mean? Bundler::URI::QUERY -# uninitialized constant Bundler::URI::MailTo::REGISTRY -# Did you mean? Bundler::URI::REGISTRY -# uninitialized constant Bundler::URI::MailTo::REL_PATH -# Did you mean? Bundler::URI::REL_PATH -# uninitialized constant Bundler::URI::MailTo::REL_URI -# Did you mean? Bundler::URI::REL_URI -# uninitialized constant Bundler::URI::MailTo::REL_URI_REF -# Did you mean? Bundler::URI::REL_URI_REF -# uninitialized constant Bundler::URI::MailTo::RFC3986_PARSER -# Did you mean? Bundler::URI::MailTo::RFC3986_Parser -# Bundler::URI::RFC3986_Parser -# Bundler::URI::RFC2396_Parser -# Bundler::URI::MailTo::RFC2396_Parser -# Bundler::URI::RFC3986_PARSER -# uninitialized constant Bundler::URI::MailTo::SCHEME -# Did you mean? Bundler::URI::SCHEME -# uninitialized constant Bundler::URI::MailTo::TBLDECWWWCOMP_ -# Did you mean? Bundler::URI::MailTo::TBLENCWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::MailTo::TBLENCWWWCOMP_ -# Did you mean? Bundler::URI::MailTo::TBLDECWWWCOMP_ -# Bundler::URI::TBLDECWWWCOMP_ -# Bundler::URI::TBLENCWWWCOMP_ -# uninitialized constant Bundler::URI::MailTo::UNSAFE -# Did you mean? Bundler::URI::UNSAFE -# uninitialized constant Bundler::URI::MailTo::URI_REF -# Did you mean? Bundler::URI::URI_REF -# uninitialized constant Bundler::URI::MailTo::USERINFO -# Did you mean? Bundler::URI::USERINFO -# uninitialized constant Bundler::URI::MailTo::USE_REGISTRY -# uninitialized constant Bundler::URI::MailTo::VERSION -# Did you mean? Bundler::URI::VERSION -# Bundler::VERSION -# uninitialized constant Bundler::URI::MailTo::VERSION_CODE -# Did you mean? Bundler::URI::VERSION_CODE -# uninitialized constant Bundler::URI::MailTo::WEB_ENCODINGS_ -# Did you mean? Bundler::URI::WEB_ENCODINGS_ -# wrong constant name headers -# wrong constant name headers= -# wrong constant name initialize -# wrong constant name set_headers -# wrong constant name set_to -# wrong constant name to -# wrong constant name to= -# wrong constant name to_mailtext -# wrong constant name to_rfc822text -# wrong constant name <static-init> -# wrong constant name escape -# wrong constant name extract -# wrong constant name initialize -# wrong constant name join -# wrong constant name make_regexp -# wrong constant name parse -# wrong constant name pattern -# wrong constant name regexp -# wrong constant name split -# wrong constant name unescape -# wrong constant name <static-init> -# wrong constant name <Class:PATTERN> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name join -# wrong constant name parse -# wrong constant name regexp -# wrong constant name split -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name make_components_hash -# wrong constant name <static-init> -# wrong constant name decode_www_form -# wrong constant name decode_www_form_component -# wrong constant name encode_www_form -# wrong constant name encode_www_form_component -# wrong constant name extract -# wrong constant name get_encoding -# wrong constant name join -# wrong constant name parse -# wrong constant name regexp -# wrong constant name scheme_list -# wrong constant name split -# wrong constant name <Class:NEq> -# wrong constant name <Class:ReqR> -# uninitialized constant Bundler::VersionRanges::NEq::Elem -# wrong constant name version -# wrong constant name version= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <=> -# uninitialized constant Bundler::VersionRanges::ReqR::Elem -# wrong constant name <Class:Endpoint> -# wrong constant name cover? -# wrong constant name empty? -# wrong constant name left -# wrong constant name left= -# wrong constant name right -# wrong constant name right= -# wrong constant name single? -# wrong constant name <=> -# uninitialized constant Bundler::VersionRanges::ReqR::Endpoint::Elem -# wrong constant name inclusive -# wrong constant name inclusive= -# wrong constant name version -# wrong constant name version= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# wrong constant name empty? -# wrong constant name for -# wrong constant name for_many -# uninitialized constant Bundler::YAMLSerializer -# uninitialized constant Bundler::YAMLSerializer -# wrong constant name original_exec -# wrong constant name original_system -# wrong constant name unbundled_env -# wrong constant name unbundled_exec -# wrong constant name unbundled_system -# wrong constant name <Class:ThreadsTable> -# wrong constant name <static-init> -# wrong constant name a -# wrong constant name base -# wrong constant name blockquote -# wrong constant name caption -# wrong constant name checkbox -# wrong constant name checkbox_group -# wrong constant name file_field -# wrong constant name form -# wrong constant name hidden -# wrong constant name html -# wrong constant name image_button -# wrong constant name img -# wrong constant name multipart_form -# wrong constant name password_field -# wrong constant name popup_menu -# wrong constant name radio_button -# wrong constant name radio_group -# wrong constant name reset -# wrong constant name scrolling_list -# wrong constant name submit -# wrong constant name text_field -# wrong constant name textarea -# wrong constant name <static-init> -# uninitialized constant CMath -# uninitialized constant CMath -# uninitialized constant CSV -# uninitialized constant CSV -# wrong constant name json_creatable? -# wrong constant name <Class:Duo> -# wrong constant name <Class:FileType> -# wrong constant name <Class:Scanners> -# wrong constant name <Class:Styles> -# wrong constant name <Class:Tokens> -# wrong constant name <Class:TokensProxy> -# wrong constant name call -# wrong constant name encode -# wrong constant name encoder -# wrong constant name format -# wrong constant name format= -# wrong constant name highlight -# wrong constant name initialize -# wrong constant name lang -# wrong constant name lang= -# wrong constant name options -# wrong constant name options= -# wrong constant name scanner -# wrong constant name <static-init> -# wrong constant name [] -# uninitialized constant CodeRay::Encoders::Terminal::DEFAULT_OPTIONS -# wrong constant name <Class:UnknownFileType> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name fetch -# wrong constant name type_from_shebang -# wrong constant name <Class:Scanner> -# uninitialized constant CodeRay::Scanners::Scanner::Elem -# uninitialized constant CodeRay::Scanners::Scanner::Id -# wrong constant name <Class:ScanError> -# uninitialized constant CodeRay::Scanners::Scanner::Version -# Did you mean? CodeRay::VERSION -# wrong constant name binary_string -# wrong constant name column -# wrong constant name each -# wrong constant name file_extension -# wrong constant name initialize -# wrong constant name lang -# wrong constant name line -# wrong constant name raise_inspect -# wrong constant name raise_inspect_arguments -# wrong constant name reset_instance -# wrong constant name scan_rest -# wrong constant name scan_tokens -# wrong constant name scanner_state_info -# wrong constant name set_string_from_source -# wrong constant name set_tokens_from_options -# wrong constant name setup -# wrong constant name state -# wrong constant name state= -# wrong constant name string= -# wrong constant name tokenize -# wrong constant name tokens -# wrong constant name tokens_last -# wrong constant name tokens_size -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name encode_with_encoding -# wrong constant name encoding -# wrong constant name file_extension -# wrong constant name guess_encoding -# wrong constant name lang -# wrong constant name normalize -# wrong constant name to_unix -# wrong constant name <static-init> -# wrong constant name <Class:Style> -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant CodeRay::Tokens::Elem -# wrong constant name begin_group -# wrong constant name begin_line -# wrong constant name count -# wrong constant name encode -# wrong constant name end_group -# wrong constant name end_line -# wrong constant name method_missing -# wrong constant name scanner -# wrong constant name scanner= -# wrong constant name split_into_parts -# wrong constant name text_token -# wrong constant name tokens -# wrong constant name <static-init> -# wrong constant name block -# wrong constant name block= -# wrong constant name each -# wrong constant name encode -# wrong constant name initialize -# wrong constant name input -# wrong constant name input= -# wrong constant name lang -# wrong constant name lang= -# wrong constant name method_missing -# wrong constant name options -# wrong constant name options= -# wrong constant name scanner -# wrong constant name tokens -# wrong constant name <static-init> -# uninitialized constant Continuation -# uninitialized constant Continuation -# uninitialized constant Coverage -# uninitialized constant Coverage -# uninitialized constant DBM -# uninitialized constant DBM -# uninitialized constant DBMError -# uninitialized constant DBMError -# wrong constant name _dump -# wrong constant name _load -# wrong constant name alive? -# wrong constant name close -# wrong constant name initialize -# wrong constant name send_message -# wrong constant name uri -# wrong constant name make_pool -# wrong constant name open -# wrong constant name stop_pool -# wrong constant name dump -# wrong constant name initialize -# wrong constant name load -# wrong constant name recv_reply -# wrong constant name recv_request -# wrong constant name send_reply -# wrong constant name send_request -# wrong constant name == -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name prepare_backtrace -# wrong constant name with_friend -# wrong constant name auto_load -# wrong constant name initialize -# wrong constant name <Class:InvokeMethod> -# wrong constant name <Class:InvokeMethod18Mixin> -# wrong constant name initialize -# wrong constant name safe_level -# wrong constant name initialize -# wrong constant name perform -# wrong constant name <static-init> -# wrong constant name block_yield -# wrong constant name perform_with_block -# wrong constant name <static-init> -# wrong constant name default_safe_level -# wrong constant name make_config -# wrong constant name accept -# wrong constant name alive? -# wrong constant name close -# wrong constant name initialize -# wrong constant name peeraddr -# wrong constant name recv_reply -# wrong constant name recv_request -# wrong constant name send_reply -# wrong constant name send_request -# wrong constant name set_sockopt -# wrong constant name shutdown -# wrong constant name stream -# wrong constant name uri -# wrong constant name getservername -# wrong constant name open -# wrong constant name open_server -# wrong constant name open_server_inaddr_any -# wrong constant name parse_uri -# wrong constant name uri_option -# wrong constant name == -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name option -# wrong constant name <static-init> -# wrong constant name _dump -# wrong constant name _dump -# wrong constant name _load -# wrong constant name _dump -# wrong constant name initialize -# wrong constant name _load -# wrong constant name _execute -# wrong constant name alive? -# wrong constant name initialize -# wrong constant name kill -# wrong constant name method_missing -# wrong constant name <static-init> -# wrong constant name mutex -# wrong constant name infinite? -# wrong constant name initialize -# wrong constant name class_name -# wrong constant name class_names -# wrong constant name corrections -# wrong constant name initialize -# wrong constant name scopes -# wrong constant name call -# wrong constant name <static-init> -# wrong constant name corrections -# wrong constant name original_message -# wrong constant name spell_checker -# wrong constant name to_s -# uninitialized constant DidYouMean::Formatter -# uninitialized constant DidYouMean::Formatter -# wrong constant name distance -# wrong constant name distance -# wrong constant name corrections -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name distance -# wrong constant name min3 -# wrong constant name corrections -# wrong constant name initialize -# wrong constant name method_name -# wrong constant name method_names -# wrong constant name names_to_exclude -# wrong constant name receiver -# wrong constant name corrections -# wrong constant name initialize -# wrong constant name call -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name message_for -# wrong constant name <static-init> -# wrong constant name augment -# wrong constant name correct -# wrong constant name dictionary -# wrong constant name dimensions -# wrong constant name initialize -# wrong constant name separator -# wrong constant name <static-init> -# wrong constant name corrections -# wrong constant name cvar_names -# wrong constant name initialize -# wrong constant name ivar_names -# wrong constant name lvar_names -# wrong constant name method_names -# wrong constant name name -# wrong constant name correct_error -# wrong constant name formatter -# wrong constant name formatter= -# wrong constant name children -# wrong constant name each_child -# wrong constant name exists? -# wrong constant name def_method -# wrong constant name def_module -# wrong constant name _dump -# wrong constant name initialize -# wrong constant name _load -# wrong constant name + -# wrong constant name <Class:ArithmeticSequence> -# wrong constant name <Class:Chain> -# wrong constant name <Class:Producer> -# wrong constant name each_with_index -# uninitialized constant Enumerator::ArithmeticSequence::Elem -# wrong constant name begin -# wrong constant name each -# wrong constant name end -# wrong constant name exclude_end? -# wrong constant name last -# wrong constant name step -# wrong constant name <static-init> -# uninitialized constant Enumerator::Chain::Elem -# wrong constant name <static-init> -# wrong constant name each -# wrong constant name initialize -# wrong constant name each -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant ErrorHighlight -# uninitialized constant ErrorHighlight -# wrong constant name gid -# wrong constant name gid= -# wrong constant name mem -# wrong constant name mem= -# wrong constant name name -# wrong constant name name= -# wrong constant name passwd -# wrong constant name passwd= -# wrong constant name [] -# wrong constant name each -# wrong constant name members -# wrong constant name <Class:Group> -# wrong constant name change -# wrong constant name change= -# wrong constant name dir= -# wrong constant name expire -# wrong constant name expire= -# wrong constant name gecos -# wrong constant name gecos= -# wrong constant name gid= -# wrong constant name name= -# wrong constant name passwd= -# wrong constant name shell= -# wrong constant name uclass -# wrong constant name uclass= -# wrong constant name uid= -# wrong constant name [] -# wrong constant name each -# wrong constant name members -# wrong constant name <Class:Passwd> -# uninitialized constant Exception2MessageMapper -# uninitialized constant Exception2MessageMapper -# wrong constant name <static-init> -# uninitialized constant Fcntl -# uninitialized constant Fcntl -# wrong constant name initialize -# wrong constant name transfer -# wrong constant name current -# uninitialized constant Fiddle -# Did you mean? File -# uninitialized constant Fiddle -# Did you mean? File -# wrong constant name absolute_path? -# wrong constant name cleanpath -# wrong constant name exists? -# wrong constant name open! -# wrong constant name read_binary -# wrong constant name relative_path -# uninitialized constant FileUtils::DryRun::LN_SUPPORTED -# Did you mean? FileUtils::LN_SUPPORTED -# uninitialized constant FileUtils::DryRun::RUBY -# Did you mean? FileUtils::RUBY -# uninitialized constant FileUtils::DryRun::VERSION -# Did you mean? FileUtils::VERSION -# uninitialized constant FileUtils::NoWrite::LN_SUPPORTED -# Did you mean? FileUtils::LN_SUPPORTED -# uninitialized constant FileUtils::NoWrite::RUBY -# Did you mean? FileUtils::RUBY -# uninitialized constant FileUtils::NoWrite::VERSION -# Did you mean? FileUtils::VERSION -# uninitialized constant FileUtils::Verbose::LN_SUPPORTED -# Did you mean? FileUtils::LN_SUPPORTED -# uninitialized constant FileUtils::Verbose::RUBY -# Did you mean? FileUtils::RUBY -# uninitialized constant FileUtils::Verbose::VERSION -# Did you mean? FileUtils::VERSION -# wrong constant name <Class:Find> -# wrong constant name _compile_method -# wrong constant name _delegator_method -# wrong constant name _valid_method? -# wrong constant name debug -# wrong constant name debug= -# wrong constant name garbage_collect -# wrong constant name verify_transient_heap_internal_consistency -# uninitialized constant GDBM -# uninitialized constant GDBM -# uninitialized constant GDBMError -# uninitialized constant GDBMError -# uninitialized constant GDBMFatalError -# uninitialized constant GDBMFatalError -# wrong constant name <Class:RuntimeRequirementNotMetError> -# wrong constant name <Class:SpecFetcher> -# wrong constant name <Class:SpecificationPolicy> -# wrong constant name <Class:UninstallError> -# wrong constant name <static-init> -# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MONITOR -# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MUTEX -# wrong constant name <static-init> -# wrong constant name build -# wrong constant name get_relative_path -# wrong constant name <Class:DigestIO> -# wrong constant name <Class:FileSource> -# wrong constant name <Class:IOSource> -# wrong constant name <Class:Old> -# wrong constant name <Class:Source> -# wrong constant name <Class:TarHeader> -# wrong constant name gem -# wrong constant name digests -# wrong constant name initialize -# wrong constant name write -# wrong constant name <static-init> -# wrong constant name wrap -# wrong constant name initialize -# wrong constant name path -# wrong constant name present? -# wrong constant name start -# wrong constant name with_read_io -# wrong constant name with_write_io -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name io -# wrong constant name path -# wrong constant name present? -# wrong constant name start -# wrong constant name with_read_io -# wrong constant name with_write_io -# wrong constant name <static-init> -# wrong constant name extract_files -# wrong constant name file_list -# wrong constant name read_until_dashes -# wrong constant name skip_ruby -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name == -# wrong constant name checksum -# wrong constant name devmajor -# wrong constant name devminor -# wrong constant name empty? -# wrong constant name gid -# wrong constant name gname -# wrong constant name initialize -# wrong constant name linkname -# wrong constant name magic -# wrong constant name mode -# wrong constant name mtime -# wrong constant name name -# wrong constant name prefix -# wrong constant name size -# wrong constant name typeflag -# wrong constant name uid -# wrong constant name uname -# wrong constant name update_checksum -# wrong constant name version -# wrong constant name <static-init> -# wrong constant name from -# wrong constant name oct_or_256based -# wrong constant name strict_oct -# wrong constant name bytes_read -# wrong constant name check_closed -# wrong constant name close -# wrong constant name closed? -# wrong constant name directory? -# wrong constant name eof? -# wrong constant name file? -# wrong constant name full_name -# wrong constant name getc -# wrong constant name header -# wrong constant name initialize -# wrong constant name length -# wrong constant name pos -# wrong constant name read -# wrong constant name readpartial -# wrong constant name rewind -# wrong constant name size -# wrong constant name symlink? -# wrong constant name <static-init> -# wrong constant name new -# wrong constant name new -# wrong constant name new -# wrong constant name raw_spec -# wrong constant name home -# wrong constant name initialize -# wrong constant name path -# wrong constant name spec_cache_dir -# wrong constant name initialize -# wrong constant name uri -# wrong constant name uri= -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name add_edge_no_circular -# wrong constant name add_vertex -# wrong constant name delete_edge -# wrong constant name detach_vertex_named -# wrong constant name each -# wrong constant name pop! -# wrong constant name reverse_each -# wrong constant name rewind_to -# wrong constant name set_payload -# wrong constant name tag -# wrong constant name <static-init> -# uninitialized constant Gem::Resolver::Molinillo::DependencyGraph::Log::Elem -# wrong constant name suggestion -# wrong constant name suggestion= -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name cert_chain -# wrong constant name cert_chain= -# wrong constant name digest_algorithm -# wrong constant name digest_name -# wrong constant name extract_name -# wrong constant name initialize -# wrong constant name key -# wrong constant name key= -# wrong constant name load_cert_chain -# wrong constant name options -# wrong constant name re_sign_key -# wrong constant name sign -# wrong constant name re_sign_cert -# wrong constant name cert_path -# wrong constant name dir -# wrong constant name each_certificate -# wrong constant name initialize -# wrong constant name issuer_of -# wrong constant name load_certificate -# wrong constant name name_path -# wrong constant name trust_cert -# wrong constant name verify -# wrong constant name alt_name_or_x509_entry -# wrong constant name create_cert -# wrong constant name create_cert_email -# wrong constant name create_cert_self_signed -# wrong constant name create_key -# wrong constant name email_to_name -# wrong constant name re_sign -# wrong constant name reset -# wrong constant name sign -# wrong constant name trust_dir -# wrong constant name trusted_certificates -# wrong constant name write -# wrong constant name available_specs -# wrong constant name detect -# wrong constant name initialize -# wrong constant name latest_specs -# wrong constant name prerelease_specs -# wrong constant name search_for_dependency -# wrong constant name sources -# wrong constant name spec_for_dependency -# wrong constant name specs -# wrong constant name suggest_gems_from_name -# wrong constant name tuples_for -# wrong constant name <static-init> -# wrong constant name fetcher -# wrong constant name fetcher= -# wrong constant name <=> -# uninitialized constant Gem::Specification::GENERICS -# uninitialized constant Gem::Specification::GENERIC_CACHE -# wrong constant name removed_method_calls -# wrong constant name to_ruby -# wrong constant name initialize -# wrong constant name packaging -# wrong constant name packaging= -# wrong constant name validate -# wrong constant name validate_dependencies -# wrong constant name validate_metadata -# wrong constant name validate_permissions -# wrong constant name <static-init> -# uninitialized constant Gem::Stream -# Did you mean? Gem::StreamUI -# uninitialized constant Gem::Stream -# Did you mean? Gem::StreamUI -# wrong constant name _deprecated_debug -# wrong constant name build_extensions -# wrong constant name extensions -# wrong constant name initialize -# wrong constant name missing_extensions? -# wrong constant name valid? -# wrong constant name extensions -# wrong constant name full_name -# wrong constant name initialize -# wrong constant name name -# wrong constant name platform -# wrong constant name require_paths -# wrong constant name version -# wrong constant name default_gemspec_stub -# wrong constant name gemspec_stub -# wrong constant name spec -# wrong constant name spec= -# wrong constant name <static-init> -# wrong constant name activated_gem_paths -# uninitialized constant GetoptLong -# uninitialized constant GetoptLong -# wrong constant name deconstruct_keys -# wrong constant name ruby2_keywords_hash -# wrong constant name ruby2_keywords_hash? -# wrong constant name <Class:ConsoleMode> -# wrong constant name beep -# wrong constant name check_winsize_changed -# wrong constant name clear_screen -# wrong constant name console_mode -# wrong constant name console_mode= -# wrong constant name cooked -# wrong constant name cooked! -# wrong constant name cursor -# wrong constant name cursor= -# wrong constant name cursor_down -# wrong constant name cursor_left -# wrong constant name cursor_right -# wrong constant name cursor_up -# wrong constant name echo= -# wrong constant name echo? -# wrong constant name erase_line -# wrong constant name erase_screen -# wrong constant name getch -# wrong constant name getpass -# wrong constant name goto -# wrong constant name goto_column -# wrong constant name iflush -# wrong constant name ioflush -# wrong constant name noecho -# wrong constant name nonblock -# wrong constant name nonblock= -# wrong constant name nonblock? -# wrong constant name nread -# wrong constant name oflush -# wrong constant name pathconf -# wrong constant name pressed? -# wrong constant name raw -# wrong constant name raw! -# wrong constant name ready? -# wrong constant name scroll_backward -# wrong constant name scroll_forward -# wrong constant name wait -# wrong constant name wait_readable -# wrong constant name wait_writable -# wrong constant name winsize -# wrong constant name winsize= -# wrong constant name echo= -# wrong constant name raw -# wrong constant name raw! -# wrong constant name <static-init> -# wrong constant name console -# wrong constant name console_size -# wrong constant name default_console_size -# wrong constant name == -# wrong constant name initialize -# wrong constant name <Class:Color> -# wrong constant name <Class:DefaultEncodings> -# wrong constant name <Class:InputCompletor> -# wrong constant name <Class:Locale> -# wrong constant name <static-init> -# wrong constant name clear -# wrong constant name colorable? -# wrong constant name colorize -# wrong constant name colorize_code -# wrong constant name inspect_colorable? -# wrong constant name __exit__ -# wrong constant name __inspect__ -# wrong constant name __to_s__ -# wrong constant name echo_on_assignment -# wrong constant name echo_on_assignment= -# wrong constant name echo_on_assignment? -# wrong constant name evaluate -# wrong constant name initialize -# wrong constant name inspect_last_value -# wrong constant name newline_before_multiline_output -# wrong constant name newline_before_multiline_output= -# wrong constant name newline_before_multiline_output? -# wrong constant name omit_on_assignment -# wrong constant name omit_on_assignment= -# wrong constant name omit_on_assignment? -# wrong constant name use_colorize -# wrong constant name use_colorize? -# wrong constant name use_multiline -# wrong constant name use_multiline? -# wrong constant name use_reidline -# wrong constant name use_reidline? -# wrong constant name use_singleline -# wrong constant name use_singleline? -# uninitialized constant IRB::DefaultEncodings::Elem -# wrong constant name external -# wrong constant name external= -# wrong constant name internal -# wrong constant name internal= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name irb -# wrong constant name irb_change_workspace -# wrong constant name irb_current_working_workspace -# wrong constant name irb_fg -# wrong constant name irb_help -# wrong constant name irb_info -# wrong constant name irb_jobs -# wrong constant name irb_kill -# wrong constant name irb_pop_workspace -# wrong constant name irb_push_workspace -# wrong constant name irb_source -# wrong constant name irb_workspaces -# wrong constant name irb_original_method_name -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name ignored_modules -# wrong constant name retrieve_completion_data -# wrong constant name select_message -# wrong constant name initialize -# wrong constant name winsize -# wrong constant name initialize -# wrong constant name assignment_expression? -# wrong constant name handle_exception -# wrong constant name initialize -# wrong constant name output_value -# wrong constant name prompt -# uninitialized constant IRB::Locale::String -# Did you mean? StringIO -# STDIN -# wrong constant name encoding -# wrong constant name find -# wrong constant name format -# wrong constant name gets -# wrong constant name initialize -# wrong constant name lang -# wrong constant name load -# wrong constant name modifier -# wrong constant name print -# wrong constant name printf -# wrong constant name puts -# wrong constant name readline -# wrong constant name require -# wrong constant name territory -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize_readline -# uninitialized constant IRB::ReidlineInputMethod::FILENAME_COMPLETION_PROC -# Did you mean? IRB::ReidlineInputMethod::USERNAME_COMPLETION_PROC -# uninitialized constant IRB::ReidlineInputMethod::HISTORY -# Did you mean? IRB::ReidlineInputMethod::History -# uninitialized constant IRB::ReidlineInputMethod::USERNAME_COMPLETION_PROC -# Did you mean? IRB::ReidlineInputMethod::FILENAME_COMPLETION_PROC -# uninitialized constant IRB::ReidlineInputMethod::VERSION -# Did you mean? IRB::VERSION -# wrong constant name auto_indent -# wrong constant name check_termination -# wrong constant name dynamic_prompt -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name local_variable_get -# wrong constant name local_variable_set -# wrong constant name delete_caller -# wrong constant name init_config -# wrong constant name init_error -# wrong constant name load_modules -# wrong constant name parse_opts -# wrong constant name rc_file -# wrong constant name rc_file_generators -# wrong constant name run_config -# wrong constant name setup -# wrong constant name to_bn -# wrong constant name escape_slash -# wrong constant name escape_slash= -# wrong constant name escape_slash? -# wrong constant name from_state -# wrong constant name initialize -# wrong constant name create_fast_state -# wrong constant name create_pretty_state -# wrong constant name load_file -# wrong constant name load_file! -# uninitialized constant Jacobian -# uninitialized constant Jacobian -# uninitialized constant Kconv -# uninitialized constant Kconv -# wrong constant name pretty_inspect -# wrong constant name at_exit -# uninitialized constant LUSolve -# uninitialized constant LUSolve -# wrong constant name debug! -# wrong constant name error! -# wrong constant name fatal! -# wrong constant name info! -# wrong constant name warn! -# uninitialized constant Logger::LogDevice::SiD -# uninitialized constant Matrix -# uninitialized constant Matrix -# uninitialized constant MessagePack -# uninitialized constant MessagePack -# wrong constant name enter -# wrong constant name exit -# wrong constant name mon_check_owner -# wrong constant name mon_enter -# wrong constant name mon_exit -# wrong constant name mon_locked? -# wrong constant name mon_owned? -# wrong constant name mon_synchronize -# wrong constant name mon_try_enter -# wrong constant name new_cond -# wrong constant name synchronize -# wrong constant name try_enter -# wrong constant name try_mon_enter -# wrong constant name wait_for_cond -# wrong constant name initialize -# wrong constant name initialize -# uninitialized constant MonitorMixin::ConditionVariable::Timeout -# uninitialized constant MonitorMixin::ConditionVariable::Timeout -# uninitialized constant Mutex_m -# uninitialized constant Mutex_m -# uninitialized constant NKF -# uninitialized constant NKF -# wrong constant name write_timeout -# wrong constant name write_timeout= -# uninitialized constant Net::DNS -# uninitialized constant Net::DNS -# uninitialized constant Net::FTP -# uninitialized constant Net::FTP -# uninitialized constant Net::FTPConnectionError -# uninitialized constant Net::FTPConnectionError -# uninitialized constant Net::FTPError -# Did you mean? Net::HTTPError -# uninitialized constant Net::FTPError -# Did you mean? Net::HTTPError -# uninitialized constant Net::FTPPermError -# Did you mean? FiberError -# uninitialized constant Net::FTPPermError -# Did you mean? FiberError -# uninitialized constant Net::FTPProtoError -# uninitialized constant Net::FTPProtoError -# uninitialized constant Net::FTPReplyError -# uninitialized constant Net::FTPReplyError -# uninitialized constant Net::FTPTempError -# Did you mean? TypeError -# uninitialized constant Net::FTPTempError -# Did you mean? TypeError -# wrong constant name ipaddr -# wrong constant name ipaddr= -# wrong constant name max_retries -# wrong constant name max_retries= -# wrong constant name max_version -# wrong constant name max_version= -# wrong constant name min_version -# wrong constant name min_version= -# wrong constant name write_timeout -# wrong constant name write_timeout= -# uninitialized constant Net::HTTP::DigestAuth -# uninitialized constant Net::HTTP::DigestAuth -# uninitialized constant Net::HTTPAlreadyReported::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPAlreadyReported::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPEarlyHints::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPEarlyHints::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPLoopDetected::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPLoopDetected::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPMisdirectedRequest::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPMisdirectedRequest::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPNotExtended::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPNotExtended::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPPayloadTooLarge::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPPayloadTooLarge::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPProcessing::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPProcessing::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPRangeNotSatisfiable::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPRangeNotSatisfiable::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPURITooLong::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPURITooLong::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::HTTPVariantAlsoNegotiates::CODE_CLASS_TO_OBJ -# uninitialized constant Net::HTTPVariantAlsoNegotiates::CODE_TO_OBJ -# wrong constant name <static-init> -# uninitialized constant Net::IMAP -# uninitialized constant Net::IMAP -# uninitialized constant Net::NTLM -# uninitialized constant Net::NTLM -# wrong constant name initialize -# wrong constant name io -# uninitialized constant Net::SMTP -# uninitialized constant Net::SMTP -# uninitialized constant Net::SMTPAuthenticationError -# uninitialized constant Net::SMTPAuthenticationError -# uninitialized constant Net::SMTPError -# Did you mean? Net::HTTPError -# uninitialized constant Net::SMTPError -# Did you mean? Net::HTTPError -# uninitialized constant Net::SMTPFatalError -# Did you mean? Net::ProtoFatalError -# Net::HTTPFatalError -# uninitialized constant Net::SMTPFatalError -# Did you mean? Net::ProtoFatalError -# Net::HTTPFatalError -# uninitialized constant Net::SMTPServerBusy -# uninitialized constant Net::SMTPServerBusy -# uninitialized constant Net::SMTPSyntaxError -# Did you mean? Net::ProtoSyntaxError -# uninitialized constant Net::SMTPSyntaxError -# Did you mean? Net::ProtoSyntaxError -# uninitialized constant Net::SMTPUnknownError -# uninitialized constant Net::SMTPUnknownError -# uninitialized constant Net::SMTPUnsupportedCommand -# uninitialized constant Net::SMTPUnsupportedCommand -# wrong constant name initialize -# wrong constant name io -# uninitialized constant Newton -# uninitialized constant Newton -# wrong constant name <static-init> -# uninitialized constant RUBYGEMS_ACTIVATION_MONITOR -# wrong constant name to_yaml -# wrong constant name yaml_tag -# wrong constant name <Class:Object> -# uninitialized constant Observable -# uninitialized constant Observable -# uninitialized constant Open3 -# Did you mean? OpenURI -# uninitialized constant Open3 -# Did you mean? OpenURI -# wrong constant name indefinite_length -# wrong constant name indefinite_length= -# wrong constant name +@ -# wrong constant name -@ -# wrong constant name / -# wrong constant name negative? -# uninitialized constant OpenSSL::Digest::DSS -# uninitialized constant OpenSSL::Digest::DSS -# uninitialized constant OpenSSL::Digest::DSS1 -# uninitialized constant OpenSSL::Digest::DSS1 -# uninitialized constant OpenSSL::Digest::SHA -# Did you mean? OpenSSL::Digest::SHA1 -# uninitialized constant OpenSSL::Digest::SHA -# Did you mean? OpenSSL::Digest::SHA1 -# wrong constant name <Class:KDFError> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name hkdf -# wrong constant name pbkdf2_hmac -# wrong constant name scrypt -# wrong constant name signed? -# uninitialized constant OpenSSL::PKCS5::PKCS5Error -# uninitialized constant OpenSSL::PKCS5::PKCS5Error -# wrong constant name to_octet_string -# wrong constant name alpn_protocols -# wrong constant name alpn_protocols= -# wrong constant name alpn_select_cb -# wrong constant name alpn_select_cb= -# wrong constant name enable_fallback_scsv -# wrong constant name max_version= -# wrong constant name min_version= -# uninitialized constant OpenSSL::SSL::SSLSocket::BLOCK_SIZE -# wrong constant name alpn_protocol -# wrong constant name tmp_key -# wrong constant name == -# wrong constant name == -# wrong constant name == -# wrong constant name to_utf8 -# wrong constant name == -# wrong constant name == -# wrong constant name to_der -# wrong constant name fips_mode -# wrong constant name additional_message -# wrong constant name get_candidates -# wrong constant name additional -# wrong constant name additional= -# uninitialized constant PStore -# uninitialized constant PStore -# uninitialized constant PTY -# Did you mean? Pry -# uninitialized constant PTY -# Did you mean? Pry -# uninitialized constant PackageSpec -# uninitialized constant PackageSpec -# wrong constant name <Class:PackageSpec> -# uninitialized constant Parser::Ruby24::Racc_Main_Parsing_Routine -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Id_C -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Version_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Revision -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Version -# Parser::Ruby24::Racc_Runtime_Core_Version_C -# Parser::Ruby24::Racc_Runtime_Core_Version_R -# Parser::Ruby24::Racc_Runtime_Version -# Parser::Ruby24::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Version_C -# Parser::Ruby24::Racc_Runtime_Core_Version_R -# Parser::Ruby24::Racc_Runtime_Core_Version -# Parser::Ruby24::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Version_C -# Parser::Ruby24::Racc_Runtime_Core_Version_R -# Parser::Ruby24::Racc_Runtime_Core_Version -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Version -# Did you mean? Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Revision -# Parser::Ruby24::Racc_Runtime_Core_Version_R -# Parser::Ruby24::Racc_Runtime_Core_Version_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Parser::Ruby24::Racc_Runtime_Version -# Parser::Ruby24::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Version_C -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Version_R -# Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Revision -# Parser::Ruby24::Racc_Runtime_Version -# Parser::Ruby24::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Core_Version_R -# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Version_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_C -# Parser::Ruby24::Racc_Runtime_Core_Revision_R -# Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Revision -# Parser::Ruby24::Racc_Runtime_Version -# Parser::Ruby24::Racc_Runtime_Core_Id_C -# uninitialized constant Parser::Ruby24::Racc_Runtime_Revision -# Did you mean? Parser::Ruby24::Racc_Runtime_Version -# Parser::Ruby24::Racc_Runtime_Core_Version -# Parser::Ruby24::Racc_Runtime_Core_Revision -# uninitialized constant Parser::Ruby24::Racc_Runtime_Type -# uninitialized constant Parser::Ruby24::Racc_Runtime_Version -# Did you mean? Parser::Ruby24::Racc_Runtime_Revision -# Parser::Ruby24::Racc_Runtime_Core_Version -# uninitialized constant Parser::Ruby24::Racc_YY_Parse_Method -# uninitialized constant Prime -# uninitialized constant Prime -# wrong constant name << -# wrong constant name >> -# wrong constant name clone -# uninitialized constant Proc0 -# uninitialized constant Proc0 -# uninitialized constant Proc1 -# uninitialized constant Proc1 -# uninitialized constant Proc10 -# uninitialized constant Proc10 -# uninitialized constant Proc2 -# uninitialized constant Proc2 -# uninitialized constant Proc3 -# uninitialized constant Proc3 -# uninitialized constant Proc4 -# uninitialized constant Proc4 -# uninitialized constant Proc5 -# uninitialized constant Proc5 -# uninitialized constant Proc6 -# uninitialized constant Proc6 -# uninitialized constant Proc7 -# uninitialized constant Proc7 -# uninitialized constant Proc8 -# uninitialized constant Proc8 -# uninitialized constant Proc9 -# uninitialized constant Proc9 -# uninitialized constant ProgressBar::Outputs::NonTty::DEFAULT_OUTPUT_STREAM -# uninitialized constant ProgressBar::Outputs::Tty::DEFAULT_OUTPUT_STREAM -# uninitialized constant Pry::BasicObject::RUBYGEMS_ACTIVATION_MONITOR -# uninitialized constant Pry::Command::COLORS -# uninitialized constant Pry::Command::Ls::COLORS -# Did you mean? Pry::Command::COLORS -# uninitialized constant Pry::Command::Ls::VOID_VALUE -# Did you mean? Pry::Command::VOID_VALUE -# uninitialized constant Pry::Command::Wtf::COLORS -# Did you mean? Pry::Command::COLORS -# uninitialized constant Pry::Command::Wtf::VOID_VALUE -# Did you mean? Pry::Command::VOID_VALUE -# uninitialized constant Psych::UnsafeYAML -# uninitialized constant Psych::UnsafeYAML -# wrong constant name add_builtin_type -# wrong constant name add_domain_type -# wrong constant name add_tag -# wrong constant name domain_types -# wrong constant name domain_types= -# wrong constant name dump_tags -# wrong constant name dump_tags= -# wrong constant name libyaml_version -# wrong constant name load_tags -# wrong constant name load_tags= -# wrong constant name remove_type -# uninitialized constant RDoc::Alias::MARKUP_FORMAT -# uninitialized constant RDoc::Alias::TO_HTML_CHARACTERS -# wrong constant name initialize -# uninitialized constant RDoc::Attr::MARKUP_FORMAT -# uninitialized constant RDoc::Attr::TO_HTML_CHARACTERS -# wrong constant name initialize -# uninitialized constant RDoc::ClassModule::MARKUP_FORMAT -# uninitialized constant RDoc::ClassModule::TOMDOC_TITLES -# uninitialized constant RDoc::ClassModule::TOMDOC_TITLES_SORT -# uninitialized constant RDoc::ClassModule::TO_HTML_CHARACTERS -# uninitialized constant RDoc::ClassModule::TYPES -# wrong constant name initialize -# uninitialized constant RDoc::CodeObject::MARKUP_FORMAT -# uninitialized constant RDoc::CodeObject::TO_HTML_CHARACTERS -# wrong constant name initialize_visibility -# uninitialized constant RDoc::Comment::MARKUP_FORMAT -# uninitialized constant RDoc::Comment::TO_HTML_CHARACTERS -# wrong constant name initialize -# wrong constant name line -# wrong constant name line= -# uninitialized constant RDoc::Constant::MARKUP_FORMAT -# uninitialized constant RDoc::Constant::TO_HTML_CHARACTERS -# wrong constant name initialize -# uninitialized constant RDoc::Context::MARKUP_FORMAT -# uninitialized constant RDoc::Context::TO_HTML_CHARACTERS -# wrong constant name add_module_by_normal_module -# wrong constant name initialize_methods_etc -# uninitialized constant RDoc::Context::Section::MARKUP_FORMAT -# Did you mean? RDoc::Context::MARKUP_FORMAT -# uninitialized constant RDoc::Context::Section::TO_HTML_CHARACTERS -# Did you mean? RDoc::Context::TO_HTML_CHARACTERS -# wrong constant name initialize -# wrong constant name initialize -# uninitialized constant RDoc::ERBIO::Revision -# wrong constant name initialize -# wrong constant name detect_encoding -# wrong constant name remove_magic_comment -# wrong constant name initialize -# uninitialized constant RDoc::Generator::JsonIndex::MARKUP_FORMAT -# uninitialized constant RDoc::Generator::JsonIndex::TO_HTML_CHARACTERS -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name <Class:RegexpHandling> -# wrong constant name add_regexp_handling -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name add_regexp_handling -# wrong constant name convert_regexp_handlings -# wrong constant name regexp_handlings -# wrong constant name regexp_handling -# wrong constant name initialize -# wrong constant name add_regexp_handling_RDOCLINK -# wrong constant name add_regexp_handling_TIDYLINK -# wrong constant name convert_regexp_handling -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name [] -# wrong constant name eos? -# wrong constant name initialize -# wrong constant name matched -# wrong constant name newline! -# wrong constant name pos -# wrong constant name scan -# wrong constant name unscan -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name == -# wrong constant name initialize -# wrong constant name text -# wrong constant name text= -# wrong constant name type -# wrong constant name <static-init> -# uninitialized constant RDoc::Markup::Special -# uninitialized constant RDoc::Markup::Special -# uninitialized constant RDoc::Markup::ToHtml::MARKUP_FORMAT -# uninitialized constant RDoc::Markup::ToHtml::TO_HTML_CHARACTERS -# wrong constant name handle_regexp_HARD_BREAK -# wrong constant name handle_regexp_HYPERLINK -# wrong constant name handle_regexp_RDOCLINK -# wrong constant name handle_regexp_TIDYLINK -# uninitialized constant RDoc::Markup::ToHtmlCrossref::LIST_TYPE_TO_HTML -# uninitialized constant RDoc::Markup::ToHtmlCrossref::MARKUP_FORMAT -# uninitialized constant RDoc::Markup::ToHtmlCrossref::TO_HTML_CHARACTERS -# wrong constant name handle_regexp_CROSSREF -# wrong constant name initialize -# uninitialized constant RDoc::Markup::ToHtmlSnippet::LIST_TYPE_TO_HTML -# uninitialized constant RDoc::Markup::ToHtmlSnippet::MARKUP_FORMAT -# uninitialized constant RDoc::Markup::ToHtmlSnippet::TO_HTML_CHARACTERS -# wrong constant name handle_regexp_CROSSREF -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name handle_regexp_CROSSREF -# wrong constant name handle_regexp_HARD_BREAK -# wrong constant name handle_regexp_TIDYLINK -# wrong constant name initialize -# wrong constant name handle_regexp_RDOCLINK -# wrong constant name handle_regexp_TIDYLINK -# wrong constant name handle_regexp_HARD_BREAK -# wrong constant name handle_regexp_SUPPRESSED_CROSSREF -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# uninitialized constant RDoc::MethodAttr::MARKUP_FORMAT -# uninitialized constant RDoc::MethodAttr::TO_HTML_CHARACTERS -# wrong constant name initialize -# uninitialized constant RDoc::Mixin::MARKUP_FORMAT -# uninitialized constant RDoc::Mixin::TO_HTML_CHARACTERS -# wrong constant name initialize -# wrong constant name <Class:RipperStateLex> -# wrong constant name initialize -# uninitialized constant RDoc::Parser::C::MARKUP_FORMAT -# uninitialized constant RDoc::Parser::C::TO_HTML_CHARACTERS -# wrong constant name do_classes_and_modules -# wrong constant name <Class:InnerStateLex> -# wrong constant name <Class:Token> -# wrong constant name get_squashed_tk -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name on_default -# wrong constant name <static-init> -# uninitialized constant RDoc::Parser::RipperStateLex::Token::Elem -# wrong constant name char_no -# wrong constant name char_no= -# wrong constant name kind -# wrong constant name kind= -# wrong constant name line_no -# wrong constant name line_no= -# wrong constant name state -# wrong constant name state= -# wrong constant name text -# wrong constant name text= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# wrong constant name end? -# wrong constant name parse -# wrong constant name get_included_module_with_optional_parens -# wrong constant name retrieve_comment_body -# wrong constant name skip_tkspace_without_nl -# uninitialized constant RDoc::RD::BlockParser::Racc_Main_Parsing_Routine -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Revision -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# RDoc::RD::BlockParser::Racc_Runtime_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::BlockParser::Racc_Runtime_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Core_Version_R -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Core_Version_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Revision -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# RDoc::RD::BlockParser::Racc_Runtime_Core_Revision -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Type -# uninitialized constant RDoc::RD::BlockParser::Racc_Runtime_Version -# Did you mean? RDoc::RD::BlockParser::Racc_Runtime_Revision -# RDoc::RD::BlockParser::Racc_Runtime_Core_Version -# uninitialized constant RDoc::RD::BlockParser::Racc_YY_Parse_Method -# wrong constant name initialize -# uninitialized constant RDoc::RD::InlineParser::Racc_Main_Parsing_Routine -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Revision -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# RDoc::RD::InlineParser::Racc_Runtime_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::InlineParser::Racc_Runtime_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Core_Version_R -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Core_Version_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_C -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision_R -# RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Id_C -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Revision -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# RDoc::RD::InlineParser::Racc_Runtime_Core_Revision -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Type -# uninitialized constant RDoc::RD::InlineParser::Racc_Runtime_Version -# Did you mean? RDoc::RD::InlineParser::Racc_Runtime_Revision -# RDoc::RD::InlineParser::Racc_Runtime_Core_Version -# uninitialized constant RDoc::RD::InlineParser::Racc_YY_Parse_Method -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# uninitialized constant RDoc::Require::MARKUP_FORMAT -# uninitialized constant RDoc::Require::TO_HTML_CHARACTERS -# wrong constant name initialize -# uninitialized constant RDoc::RipperStateLex -# uninitialized constant RDoc::RipperStateLex -# wrong constant name initialize -# uninitialized constant RDoc::Stats::MARKUP_FORMAT -# uninitialized constant RDoc::Stats::TO_HTML_CHARACTERS -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name unmatched_constant_alias -# wrong constant name update_parser_of_file -# wrong constant name initialize -# uninitialized constant RDoc::Task::DEFAULT -# uninitialized constant RDoc::Task::LN_SUPPORTED -# uninitialized constant RDoc::Task::LOW_METHODS -# Did you mean? RDoc::Task::LowMethods -# uninitialized constant RDoc::Task::METHODS -# Did you mean? Method -# uninitialized constant RDoc::Task::OPT_TABLE -# uninitialized constant RDoc::Task::RUBY -# uninitialized constant RDoc::Task::VERSION -# Did you mean? RDoc::VERSION -# wrong constant name inline_source -# wrong constant name inline_source= -# wrong constant name language -# wrong constant name language= -# uninitialized constant RDoc::TopLevel::MARKUP_FORMAT -# uninitialized constant RDoc::TopLevel::TOMDOC_TITLES -# uninitialized constant RDoc::TopLevel::TOMDOC_TITLES_SORT -# uninitialized constant RDoc::TopLevel::TO_HTML_CHARACTERS -# uninitialized constant RDoc::TopLevel::TYPES -# wrong constant name initialize -# uninitialized constant REXML::Parsers::XPathParser::NAME -# Did you mean? REXML::Parsers::XPathParser::QNAME -# uninitialized constant REXML::Parsers::XPathParser::NAMECHAR -# Did you mean? REXML::Parsers::XPathParser::NAME_CHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_CHAR -# Did you mean? REXML::Parsers::XPathParser::NAME_STR -# REXML::Parsers::XPathParser::NAMECHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_START_CHAR -# uninitialized constant REXML::Parsers::XPathParser::NAME_STR -# Did you mean? REXML::Parsers::XPathParser::NCNAME_STR -# uninitialized constant REXML::Parsers::XPathParser::NCNAME_STR -# Did you mean? REXML::Parsers::XPathParser::NAME_STR -# uninitialized constant REXML::Parsers::XPathParser::NMTOKEN -# Did you mean? REXML::Parsers::XPathParser::NMTOKENS -# uninitialized constant REXML::Parsers::XPathParser::NMTOKENS -# Did you mean? REXML::XMLTokens -# uninitialized constant REXML::Parsers::XPathParser::REFERENCE -# uninitialized constant REXML::QuickPath -# uninitialized constant REXML::QuickPath -# uninitialized constant REXML::SAX2Listener -# uninitialized constant REXML::SAX2Listener -# uninitialized constant REXML::SyncEnumerator -# uninitialized constant REXML::SyncEnumerator -# uninitialized constant REXML::XPathParser::NAME -# uninitialized constant REXML::XPathParser::NAMECHAR -# Did you mean? REXML::XPathParser::NAME_CHAR -# uninitialized constant REXML::XPathParser::NAME_CHAR -# Did you mean? REXML::XPathParser::NAME_STR -# REXML::XPathParser::NAMECHAR -# uninitialized constant REXML::XPathParser::NAME_START_CHAR -# uninitialized constant REXML::XPathParser::NAME_STR -# Did you mean? REXML::XPathParser::NCNAME_STR -# uninitialized constant REXML::XPathParser::NCNAME_STR -# Did you mean? REXML::XPathParser::NAME_STR -# uninitialized constant REXML::XPathParser::NMTOKEN -# Did you mean? REXML::XPathParser::NMTOKENS -# uninitialized constant REXML::XPathParser::NMTOKENS -# Did you mean? REXML::XMLTokens -# uninitialized constant REXML::XPathParser::REFERENCE -# uninitialized constant RSpec::Core::ExampleGroup::NOT_YET_IMPLEMENTED -# uninitialized constant RSpec::Core::ExampleGroup::NO_REASON_GIVEN -# uninitialized constant RSpec::Matchers::BuiltIn::BePredicate::UNDEFINED -# uninitialized constant RSpec::Matchers::BuiltIn::Equal::UNDEFINED -# uninitialized constant RSpec::Matchers::BuiltIn::Has::UNDEFINED -# wrong constant name <Class:Differ> -# wrong constant name color? -# wrong constant name diff -# wrong constant name diff_as_object -# wrong constant name diff_as_string -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <Class:CparseParams> -# wrong constant name <static-init> -# uninitialized constant Ractor -# uninitialized constant Ractor -# uninitialized constant Rake::DSL::DEFAULT -# uninitialized constant Rake::DSL::LN_SUPPORTED -# uninitialized constant Rake::DSL::LOW_METHODS -# Did you mean? Rake::DSL::LowMethods -# uninitialized constant Rake::DSL::METHODS -# Did you mean? Method -# uninitialized constant Rake::DSL::OPT_TABLE -# uninitialized constant Rake::DSL::RUBY -# uninitialized constant Rake::DSL::VERSION -# Did you mean? Rake::Version -# Rake::VERSION -# uninitialized constant Rake::FileUtilsExt::LN_SUPPORTED -# uninitialized constant Rake::FileUtilsExt::LOW_METHODS -# Did you mean? Rake::FileUtilsExt::LowMethods -# uninitialized constant Rake::FileUtilsExt::METHODS -# Did you mean? Method -# uninitialized constant Rake::FileUtilsExt::OPT_TABLE -# uninitialized constant Rake::FileUtilsExt::RUBY -# uninitialized constant Rake::FileUtilsExt::VERSION -# Did you mean? Rake::Version -# Rake::VERSION -# uninitialized constant Rake::TaskLib::DEFAULT -# uninitialized constant Rake::TaskLib::LN_SUPPORTED -# uninitialized constant Rake::TaskLib::LOW_METHODS -# Did you mean? Rake::TaskLib::LowMethods -# uninitialized constant Rake::TaskLib::METHODS -# Did you mean? Method -# uninitialized constant Rake::TaskLib::OPT_TABLE -# uninitialized constant Rake::TaskLib::RUBY -# uninitialized constant Rake::TaskLib::VERSION -# Did you mean? Rake::Version -# Rake::VERSION -# wrong constant name bytes -# wrong constant name % -# wrong constant name entries -# wrong constant name to_a -# wrong constant name expand -# wrong constant name fire_update! -# wrong constant name ruby -# wrong constant name completion_quote_character -# wrong constant name vi_cmd_mode_icon -# wrong constant name vi_cmd_mode_icon= -# wrong constant name vi_ins_mode_icon -# wrong constant name vi_ins_mode_icon= -# uninitialized constant Reline::ConfigEncodingConversionError -# uninitialized constant Reline::ConfigEncodingConversionError -# wrong constant name ambiguous_width= -# uninitialized constant Reline::Core::DialogProc -# uninitialized constant Reline::Core::DialogProc -# uninitialized constant Reline::DialogRenderInfo -# uninitialized constant Reline::DialogRenderInfo -# uninitialized constant Reline::LineEditor::Dialog -# uninitialized constant Reline::LineEditor::Dialog -# uninitialized constant Reline::LineEditor::DialogProcScope -# uninitialized constant Reline::LineEditor::DialogProcScope -# uninitialized constant Reline::Terminfo -# uninitialized constant Reline::Terminfo -# wrong constant name extract_resources -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name lazy_initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name lazy_initialize -# wrong constant name initialize -# uninitialized constant Resolv::DNS::Resource::LOC::ClassHash -# Did you mean? Resolv::DNS::Resource::ClassHash -# uninitialized constant Resolv::DNS::Resource::LOC::ClassInsensitiveTypes -# Did you mean? Resolv::DNS::Resource::ClassInsensitiveTypes -# uninitialized constant Resolv::DNS::Resource::LOC::ClassValue -# Did you mean? Resolv::DNS::Resource::ClassValue -# wrong constant name initialize -# wrong constant name allocate_request_id -# wrong constant name bind_random_port -# wrong constant name free_request_id -# wrong constant name random -# uninitialized constant Rinda -# uninitialized constant Rinda -# wrong constant name <Class:Lexer> -# wrong constant name <Class:TokenPattern> -# wrong constant name column -# wrong constant name debug_output -# wrong constant name debug_output= -# wrong constant name encoding -# wrong constant name end_seen? -# wrong constant name error? -# wrong constant name filename -# wrong constant name initialize -# wrong constant name lineno -# wrong constant name parse -# wrong constant name state -# wrong constant name token -# wrong constant name yydebug -# wrong constant name yydebug= -# wrong constant name initialize -# uninitialized constant Ripper::Lexer::EVENTS -# Did you mean? Ripper::EVENTS -# uninitialized constant Ripper::Lexer::EXPR_ARG -# Did you mean? Ripper::EXPR_BEG -# Ripper::EXPR_ARG -# Ripper::Lexer::EXPR_BEG -# uninitialized constant Ripper::Lexer::EXPR_ARG_ANY -# Did you mean? Ripper::Lexer::EXPR_BEG_ANY -# Ripper::EXPR_END_ANY -# Ripper::EXPR_BEG_ANY -# Ripper::Lexer::EXPR_END_ANY -# Ripper::EXPR_ARG_ANY -# uninitialized constant Ripper::Lexer::EXPR_BEG -# Did you mean? Ripper::Lexer::EXPR_ARG -# Ripper::EXPR_BEG -# Ripper::EXPR_ARG -# uninitialized constant Ripper::Lexer::EXPR_BEG_ANY -# Did you mean? Ripper::EXPR_BEG_ANY -# Ripper::Lexer::EXPR_END_ANY -# Ripper::Lexer::EXPR_ARG_ANY -# Ripper::EXPR_ARG_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::Lexer::EXPR_CLASS -# Did you mean? Ripper::EXPR_CLASS -# uninitialized constant Ripper::Lexer::EXPR_CMDARG -# Did you mean? Ripper::Lexer::EXPR_ARG -# Ripper::EXPR_ARG -# Ripper::EXPR_CMDARG -# Ripper::Lexer::EXPR_ENDARG -# Ripper::EXPR_ENDARG -# uninitialized constant Ripper::Lexer::EXPR_DOT -# Did you mean? Ripper::EXPR_DOT -# uninitialized constant Ripper::Lexer::EXPR_END -# Did you mean? Ripper::Lexer::EXPR_MID -# Ripper::EXPR_MID -# Ripper::EXPR_END -# Ripper::Lexer::EXPR_ENDFN -# Ripper::EXPR_ENDFN -# uninitialized constant Ripper::Lexer::EXPR_ENDARG -# Did you mean? Ripper::Lexer::EXPR_ARG -# Ripper::EXPR_ARG -# Ripper::EXPR_END -# Ripper::EXPR_ENDFN -# Ripper::Lexer::EXPR_ENDFN -# Ripper::Lexer::EXPR_CMDARG -# Ripper::EXPR_CMDARG -# Ripper::EXPR_ENDARG -# Ripper::Lexer::EXPR_END_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::Lexer::EXPR_ENDFN -# Did you mean? Ripper::EXPR_END -# Ripper::EXPR_ENDFN -# Ripper::EXPR_ENDARG -# Ripper::Lexer::EXPR_ENDARG -# Ripper::Lexer::EXPR_END_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::Lexer::EXPR_END_ANY -# Did you mean? Ripper::EXPR_END_ANY -# Ripper::Lexer::EXPR_ARG_ANY -# Ripper::Lexer::EXPR_BEG_ANY -# Ripper::EXPR_ARG_ANY -# Ripper::EXPR_BEG_ANY -# Ripper::Lexer::EXPR_ENDFN -# Ripper::EXPR_ENDFN -# Ripper::Lexer::EXPR_ENDARG -# Ripper::EXPR_ENDARG -# uninitialized constant Ripper::Lexer::EXPR_FITEM -# Did you mean? Ripper::EXPR_FITEM -# uninitialized constant Ripper::Lexer::EXPR_FNAME -# Did you mean? Ripper::Lexer::EXPR_NONE -# Ripper::EXPR_NONE -# Ripper::EXPR_FNAME -# uninitialized constant Ripper::Lexer::EXPR_LABEL -# Did you mean? Ripper::EXPR_BEG -# Ripper::Lexer::EXPR_BEG -# Ripper::EXPR_LABEL -# Ripper::Lexer::EXPR_LABELED -# Ripper::EXPR_LABELED -# uninitialized constant Ripper::Lexer::EXPR_LABELED -# Did you mean? Ripper::EXPR_LABEL -# Ripper::EXPR_LABELED -# uninitialized constant Ripper::Lexer::EXPR_MID -# Did you mean? Ripper::Lexer::EXPR_END -# Ripper::EXPR_MID -# Ripper::EXPR_END -# uninitialized constant Ripper::Lexer::EXPR_NONE -# Did you mean? Ripper::Lexer::EXPR_DOT -# Ripper::Lexer::EXPR_END -# Ripper::EXPR_DOT -# Ripper::EXPR_END -# Ripper::EXPR_NONE -# Ripper::Lexer::EXPR_FNAME -# Ripper::EXPR_FNAME -# uninitialized constant Ripper::Lexer::EXPR_VALUE -# Did you mean? Ripper::EXPR_VALUE -# wrong constant name <Class:Elem> -# uninitialized constant Ripper::Lexer::PARSER_EVENTS -# Did you mean? Ripper::PARSER_EVENTS -# uninitialized constant Ripper::Lexer::PARSER_EVENT_TABLE -# Did you mean? Ripper::PARSER_EVENT_TABLE -# uninitialized constant Ripper::Lexer::SCANNER_EVENTS -# Did you mean? Ripper::SCANNER_EVENTS -# uninitialized constant Ripper::Lexer::SCANNER_EVENT_TABLE -# Did you mean? Ripper::SCANNER_EVENT_TABLE -# wrong constant name <Class:State> -# uninitialized constant Ripper::Lexer::Version -# Did you mean? Ripper::Version -# wrong constant name errors -# wrong constant name lex -# wrong constant name scan -# wrong constant name tokenize -# uninitialized constant Ripper::Lexer::Elem::Elem -# wrong constant name event -# wrong constant name event= -# wrong constant name initialize -# wrong constant name message -# wrong constant name message= -# wrong constant name pos -# wrong constant name pos= -# wrong constant name state -# wrong constant name state= -# wrong constant name tok -# wrong constant name tok= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name & -# wrong constant name == -# uninitialized constant Ripper::Lexer::State::Elem -# Did you mean? Ripper::Lexer::Elem -# wrong constant name allbits? -# wrong constant name anybits? -# wrong constant name initialize -# wrong constant name nobits? -# wrong constant name to_i -# wrong constant name to_int -# wrong constant name to_int= -# wrong constant name to_s= -# wrong constant name | -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# uninitialized constant Ripper::SexpBuilder::EVENTS -# Did you mean? Ripper::EVENTS -# uninitialized constant Ripper::SexpBuilder::EXPR_ARG -# Did you mean? Ripper::EXPR_BEG -# Ripper::EXPR_ARG -# Ripper::SexpBuilder::EXPR_BEG -# uninitialized constant Ripper::SexpBuilder::EXPR_ARG_ANY -# Did you mean? Ripper::SexpBuilder::EXPR_BEG_ANY -# Ripper::EXPR_END_ANY -# Ripper::EXPR_BEG_ANY -# Ripper::SexpBuilder::EXPR_END_ANY -# Ripper::EXPR_ARG_ANY -# uninitialized constant Ripper::SexpBuilder::EXPR_BEG -# Did you mean? Ripper::SexpBuilder::EXPR_ARG -# Ripper::EXPR_BEG -# Ripper::EXPR_ARG -# uninitialized constant Ripper::SexpBuilder::EXPR_BEG_ANY -# Did you mean? Ripper::EXPR_BEG_ANY -# Ripper::SexpBuilder::EXPR_END_ANY -# Ripper::SexpBuilder::EXPR_ARG_ANY -# Ripper::EXPR_ARG_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::SexpBuilder::EXPR_CLASS -# Did you mean? Ripper::EXPR_CLASS -# uninitialized constant Ripper::SexpBuilder::EXPR_CMDARG -# Did you mean? Ripper::SexpBuilder::EXPR_ARG -# Ripper::EXPR_ARG -# Ripper::EXPR_CMDARG -# Ripper::SexpBuilder::EXPR_ENDARG -# Ripper::EXPR_ENDARG -# uninitialized constant Ripper::SexpBuilder::EXPR_DOT -# Did you mean? Ripper::EXPR_DOT -# uninitialized constant Ripper::SexpBuilder::EXPR_END -# Did you mean? Ripper::SexpBuilder::EXPR_MID -# Ripper::EXPR_MID -# Ripper::EXPR_END -# Ripper::SexpBuilder::EXPR_ENDFN -# Ripper::EXPR_ENDFN -# uninitialized constant Ripper::SexpBuilder::EXPR_ENDARG -# Did you mean? Ripper::SexpBuilder::EXPR_ARG -# Ripper::EXPR_ARG -# Ripper::EXPR_END -# Ripper::EXPR_ENDFN -# Ripper::SexpBuilder::EXPR_ENDFN -# Ripper::SexpBuilder::EXPR_CMDARG -# Ripper::EXPR_CMDARG -# Ripper::EXPR_ENDARG -# Ripper::SexpBuilder::EXPR_END_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::SexpBuilder::EXPR_ENDFN -# Did you mean? Ripper::EXPR_END -# Ripper::EXPR_ENDFN -# Ripper::EXPR_ENDARG -# Ripper::SexpBuilder::EXPR_ENDARG -# Ripper::SexpBuilder::EXPR_END_ANY -# Ripper::EXPR_END_ANY -# uninitialized constant Ripper::SexpBuilder::EXPR_END_ANY -# Did you mean? Ripper::EXPR_END_ANY -# Ripper::SexpBuilder::EXPR_ARG_ANY -# Ripper::SexpBuilder::EXPR_BEG_ANY -# Ripper::EXPR_ARG_ANY -# Ripper::EXPR_BEG_ANY -# Ripper::SexpBuilder::EXPR_ENDFN -# Ripper::EXPR_ENDFN -# Ripper::SexpBuilder::EXPR_ENDARG -# Ripper::EXPR_ENDARG -# uninitialized constant Ripper::SexpBuilder::EXPR_FITEM -# Did you mean? Ripper::EXPR_FITEM -# uninitialized constant Ripper::SexpBuilder::EXPR_FNAME -# Did you mean? Ripper::SexpBuilder::EXPR_NONE -# Ripper::EXPR_NONE -# Ripper::EXPR_FNAME -# uninitialized constant Ripper::SexpBuilder::EXPR_LABEL -# Did you mean? Ripper::EXPR_BEG -# Ripper::SexpBuilder::EXPR_BEG -# Ripper::EXPR_LABEL -# Ripper::SexpBuilder::EXPR_LABELED -# Ripper::EXPR_LABELED -# uninitialized constant Ripper::SexpBuilder::EXPR_LABELED -# Did you mean? Ripper::EXPR_LABEL -# Ripper::EXPR_LABELED -# uninitialized constant Ripper::SexpBuilder::EXPR_MID -# Did you mean? Ripper::SexpBuilder::EXPR_END -# Ripper::EXPR_MID -# Ripper::EXPR_END -# uninitialized constant Ripper::SexpBuilder::EXPR_NONE -# Did you mean? Ripper::SexpBuilder::EXPR_DOT -# Ripper::SexpBuilder::EXPR_END -# Ripper::EXPR_DOT -# Ripper::EXPR_END -# Ripper::EXPR_NONE -# Ripper::SexpBuilder::EXPR_FNAME -# Ripper::EXPR_FNAME -# uninitialized constant Ripper::SexpBuilder::EXPR_VALUE -# Did you mean? Ripper::EXPR_VALUE -# uninitialized constant Ripper::SexpBuilder::PARSER_EVENTS -# Did you mean? Ripper::PARSER_EVENTS -# uninitialized constant Ripper::SexpBuilder::PARSER_EVENT_TABLE -# Did you mean? Ripper::PARSER_EVENT_TABLE -# uninitialized constant Ripper::SexpBuilder::SCANNER_EVENTS -# Did you mean? Ripper::SCANNER_EVENTS -# uninitialized constant Ripper::SexpBuilder::SCANNER_EVENT_TABLE -# Did you mean? Ripper::SCANNER_EVENT_TABLE -# uninitialized constant Ripper::SexpBuilder::Version -# Did you mean? Ripper::Version -# wrong constant name on_BEGIN -# wrong constant name on_CHAR -# wrong constant name on_END -# wrong constant name on___end__ -# wrong constant name on_alias -# wrong constant name on_alias_error -# wrong constant name on_aref -# wrong constant name on_aref_field -# wrong constant name on_arg_ambiguous -# wrong constant name on_arg_paren -# wrong constant name on_args_add -# wrong constant name on_args_add_block -# wrong constant name on_args_add_star -# wrong constant name on_args_forward -# wrong constant name on_args_new -# wrong constant name on_array -# wrong constant name on_aryptn -# wrong constant name on_assign -# wrong constant name on_assign_error -# wrong constant name on_assoc_new -# wrong constant name on_assoc_splat -# wrong constant name on_assoclist_from_args -# wrong constant name on_backref -# wrong constant name on_backtick -# wrong constant name on_bare_assoc_hash -# wrong constant name on_begin -# wrong constant name on_binary -# wrong constant name on_block_var -# wrong constant name on_blockarg -# wrong constant name on_bodystmt -# wrong constant name on_brace_block -# wrong constant name on_break -# wrong constant name on_call -# wrong constant name on_case -# wrong constant name on_class -# wrong constant name on_class_name_error -# wrong constant name on_comma -# wrong constant name on_command -# wrong constant name on_command_call -# wrong constant name on_comment -# wrong constant name on_const -# wrong constant name on_const_path_field -# wrong constant name on_const_path_ref -# wrong constant name on_const_ref -# wrong constant name on_cvar -# wrong constant name on_def -# wrong constant name on_defined -# wrong constant name on_defs -# wrong constant name on_do_block -# wrong constant name on_dot2 -# wrong constant name on_dot3 -# wrong constant name on_dyna_symbol -# wrong constant name on_else -# wrong constant name on_elsif -# wrong constant name on_embdoc -# wrong constant name on_embdoc_beg -# wrong constant name on_embdoc_end -# wrong constant name on_embexpr_beg -# wrong constant name on_embexpr_end -# wrong constant name on_embvar -# wrong constant name on_ensure -# wrong constant name on_excessed_comma -# wrong constant name on_fcall -# wrong constant name on_field -# wrong constant name on_float -# wrong constant name on_for -# wrong constant name on_gvar -# wrong constant name on_hash -# wrong constant name on_heredoc_beg -# wrong constant name on_heredoc_end -# wrong constant name on_hshptn -# wrong constant name on_ident -# wrong constant name on_if -# wrong constant name on_if_mod -# wrong constant name on_ifop -# wrong constant name on_ignored_nl -# wrong constant name on_ignored_sp -# wrong constant name on_imaginary -# wrong constant name on_in -# wrong constant name on_int -# wrong constant name on_ivar -# wrong constant name on_kw -# wrong constant name on_kwrest_param -# wrong constant name on_label -# wrong constant name on_label_end -# wrong constant name on_lambda -# wrong constant name on_lbrace -# wrong constant name on_lbracket -# wrong constant name on_lparen -# wrong constant name on_magic_comment -# wrong constant name on_massign -# wrong constant name on_method_add_arg -# wrong constant name on_method_add_block -# wrong constant name on_mlhs_add -# wrong constant name on_mlhs_add_post -# wrong constant name on_mlhs_add_star -# wrong constant name on_mlhs_new -# wrong constant name on_mlhs_paren -# wrong constant name on_module -# wrong constant name on_mrhs_add -# wrong constant name on_mrhs_add_star -# wrong constant name on_mrhs_new -# wrong constant name on_mrhs_new_from_args -# wrong constant name on_next -# wrong constant name on_nl -# wrong constant name on_nokw_param -# wrong constant name on_op -# wrong constant name on_opassign -# wrong constant name on_operator_ambiguous -# wrong constant name on_param_error -# wrong constant name on_params -# wrong constant name on_paren -# wrong constant name on_parse_error -# wrong constant name on_period -# wrong constant name on_program -# wrong constant name on_qsymbols_add -# wrong constant name on_qsymbols_beg -# wrong constant name on_qsymbols_new -# wrong constant name on_qwords_add -# wrong constant name on_qwords_beg -# wrong constant name on_qwords_new -# wrong constant name on_rational -# wrong constant name on_rbrace -# wrong constant name on_rbracket -# wrong constant name on_redo -# wrong constant name on_regexp_add -# wrong constant name on_regexp_beg -# wrong constant name on_regexp_end -# wrong constant name on_regexp_literal -# wrong constant name on_regexp_new -# wrong constant name on_rescue -# wrong constant name on_rescue_mod -# wrong constant name on_rest_param -# wrong constant name on_retry -# wrong constant name on_return -# wrong constant name on_return0 -# wrong constant name on_rparen -# wrong constant name on_sclass -# wrong constant name on_semicolon -# wrong constant name on_sp -# wrong constant name on_stmts_add -# wrong constant name on_stmts_new -# wrong constant name on_string_add -# wrong constant name on_string_concat -# wrong constant name on_string_content -# wrong constant name on_string_dvar -# wrong constant name on_string_embexpr -# wrong constant name on_string_literal -# wrong constant name on_super -# wrong constant name on_symbeg -# wrong constant name on_symbol -# wrong constant name on_symbol_literal -# wrong constant name on_symbols_add -# wrong constant name on_symbols_beg -# wrong constant name on_symbols_new -# wrong constant name on_tlambda -# wrong constant name on_tlambeg -# wrong constant name on_top_const_field -# wrong constant name on_top_const_ref -# wrong constant name on_tstring_beg -# wrong constant name on_tstring_content -# wrong constant name on_tstring_end -# wrong constant name on_unary -# wrong constant name on_undef -# wrong constant name on_unless -# wrong constant name on_unless_mod -# wrong constant name on_until -# wrong constant name on_until_mod -# wrong constant name on_var_alias -# wrong constant name on_var_field -# wrong constant name on_var_ref -# wrong constant name on_vcall -# wrong constant name on_void_stmt -# wrong constant name on_when -# wrong constant name on_while -# wrong constant name on_while_mod -# wrong constant name on_word_add -# wrong constant name on_word_new -# wrong constant name on_words_add -# wrong constant name on_words_beg -# wrong constant name on_words_new -# wrong constant name on_words_sep -# wrong constant name on_xstring_add -# wrong constant name on_xstring_literal -# wrong constant name on_xstring_new -# wrong constant name on_yield -# wrong constant name on_yield0 -# wrong constant name on_zsuper -# wrong constant name <Class:CompileError> -# wrong constant name <Class:Error> -# wrong constant name <Class:MatchData> -# wrong constant name <Class:MatchError> -# wrong constant name initialize -# wrong constant name match -# wrong constant name match_list -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name string -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name compile -# wrong constant name dedent_string -# wrong constant name lex_state_name -# wrong constant name token_match -# wrong constant name <Class:Colorizer> -# wrong constant name <Class:InstrumentationSubcompiler> -# wrong constant name <Class:NodePatternSubcompiler> -# wrong constant name <Class:SequenceSubcompiler> -# wrong constant name <Class:Trace> -# wrong constant name comments -# wrong constant name node_ids -# wrong constant name tokens -# wrong constant name <Class:Result> -# wrong constant name compiler -# wrong constant name initialize -# wrong constant name node_pattern -# wrong constant name pattern -# wrong constant name test -# uninitialized constant RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result::Elem -# wrong constant name color_map -# wrong constant name colorize -# wrong constant name colorizer -# wrong constant name colorizer= -# wrong constant name match_map -# wrong constant name matched? -# wrong constant name returned -# wrong constant name returned= -# wrong constant name ruby_ast -# wrong constant name ruby_ast= -# wrong constant name trace -# wrong constant name trace= -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name members -# wrong constant name <static-init> -# wrong constant name do_compile -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler::DELTA -# wrong constant name <static-init> -# wrong constant name enter -# wrong constant name matched? -# wrong constant name success -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant RuboCop::AST::NodePattern::Node::Repetition::MAP -# Did you mean? RuboCop::AST::NodePattern::Node::MAP -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Main_Parsing_Routine -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Type -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_YY_Parse_Method -# wrong constant name <Class:WithMeta> -# wrong constant name <Class:Builder> -# wrong constant name <Class:Lexer> -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Main_Parsing_Routine -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Main_Parsing_Routine -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision_R -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Id_C -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Revision -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Revision -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Type -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Type -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Version -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Revision -# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version -# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_YY_Parse_Method -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_YY_Parse_Method -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_arg -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_arg -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_debug_parser -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_debug_parser -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Racc_token_to_s_table -# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_token_to_s_table -# wrong constant name comments -# wrong constant name tokens -# wrong constant name emit_atom -# wrong constant name emit_call -# wrong constant name emit_list -# wrong constant name emit_unary_op -# wrong constant name <static-init> -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::CALL -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::CONST_NAME -# Did you mean? RuboCop::AST::ConstNode -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::IDENTIFIER -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::NODE_TYPE -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::REGEXP -# Did you mean? Regexp -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::REGEXP_BODY -# Did you mean? RuboCop::AST::RegexpNode -# uninitialized constant RuboCop::AST::NodePattern::Parser::WithMeta::Lexer::SYMBOL_NAME -# Did you mean? RuboCop::AST::SymbolNode -# wrong constant name initialize -# wrong constant name pos -# wrong constant name <static-init> -# wrong constant name <static-init> -# uninitialized constant RuboCop::AST::RegexpNode::ARGUMENT_TYPES -# uninitialized constant RuboCop::AST::RegexpNode::ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::BASIC_CONDITIONALS -# uninitialized constant RuboCop::AST::RegexpNode::BASIC_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::COMPARISON_OPERATORS -# uninitialized constant RuboCop::AST::RegexpNode::COMPOSITE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::CONDITIONALS -# uninitialized constant RuboCop::AST::RegexpNode::EQUALS_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::FALSEY_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::IMMUTABLE_LITERALS -# Did you mean? RuboCop::AST::RegexpNode::MUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::LOOP_TYPES -# uninitialized constant RuboCop::AST::RegexpNode::MUTABLE_LITERALS -# Did you mean? RuboCop::AST::RegexpNode::IMMUTABLE_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::OPERATOR_KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::POST_CONDITION_LOOP_TYPES -# uninitialized constant RuboCop::AST::RegexpNode::REFERENCES -# uninitialized constant RuboCop::AST::RegexpNode::SHORTHAND_ASSIGNMENTS -# uninitialized constant RuboCop::AST::RegexpNode::SPECIAL_KEYWORDS -# uninitialized constant RuboCop::AST::RegexpNode::TRUTHY_LITERALS -# uninitialized constant RuboCop::AST::RegexpNode::VARIABLES -# wrong constant name fixed_encoding? -# wrong constant name dot? -# wrong constant name <static-init> -# wrong constant name root_dir -# wrong constant name <static-init> -# wrong constant name find_config_path -# wrong constant name project_root -# wrong constant name project_root= -# uninitialized constant RuboCop::Cop::Base::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::DuplicatedGem::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Bundler::DuplicatedGem::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::DuplicatedGem::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Bundler::GemComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::GemComment::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Bundler::GemFilename::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Bundler::GemFilename::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::GemFilename::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Bundler::GemVersion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::GemVersion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Bundler::InsecureProtocolSource::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Bundler::InsecureProtocolSource::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::OrderedGems::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Bundler::OrderedGems::RESTRICT_ON_SEND -# wrong constant name comments_in_range -# uninitialized constant RuboCop::Cop::Corrector::ACTIONS -# Did you mean? RuboCop::Cop::Corrector::Action -# uninitialized constant RuboCop::Cop::Corrector::DEPRECATION_WARNING -# uninitialized constant RuboCop::Cop::Corrector::POLICY_TO_LEVEL -# uninitialized constant RuboCop::Cop::EndKeywordAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Gemspec::DependencyVersion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::DependencyVersion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Gemspec::DuplicatedAssignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Gemspec::DuplicatedAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::DuplicatedAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Gemspec::OrderedDependencies::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::OrderedDependencies::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Gemspec::RequireMFA::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::RequireMFA::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Gemspec::RequiredRubyVersion::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Gemspec::RequiredRubyVersion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::AccessModifierIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::ArgumentAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ArgumentAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ArgumentAlignment::SPACE -# uninitialized constant RuboCop::Cop::Layout::ArrayAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ArrayAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ArrayAlignment::SPACE -# uninitialized constant RuboCop::Cop::Layout::AssignmentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::AssignmentIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::AssignmentIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::BeginEndAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::BeginEndAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::BeginEndAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::BlockAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::BlockAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::BlockAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::BlockEndNewline::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::BlockEndNewline::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::BlockEndNewline::SPACE -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::CaseIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::ClassStructure::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ClassStructure::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ClassStructure::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Layout::ClosingHeredocIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ClosingHeredocIndentation::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Layout::ClosingHeredocIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ClosingParenthesisIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ClosingParenthesisIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ClosingParenthesisIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::CommentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::CommentIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::CommentIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::ConditionPosition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ConditionPosition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ConditionPosition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::DefEndAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::DefEndAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::DefEndAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ElseAlignment::SPACE -# uninitialized constant RuboCop::Cop::Layout::EmptyComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyComment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterGuardClause::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterGuardClause::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterGuardClause::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMagicComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMagicComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMagicComment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLineBetweenDefs::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLineBetweenDefs::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLineBetweenDefs::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLines::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLines::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLines::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundArguments::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBeginBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBlockBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundClassBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundMethodBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_DEFERRED -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_EXTRA -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::MSG_MISSING -# uninitialized constant RuboCop::Cop::Layout::EmptyLinesAroundModuleBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::EndOfLine::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::EndOfLine::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::EndOfLine::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ExtraSpacing::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::ExtraSpacing::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ExtraSpacing::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstArgumentIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementLineBreak::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstArrayElementLineBreak::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementLineBreak::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstHashElementLineBreak::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstMethodArgumentLineBreak::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstMethodParameterLineBreak::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstMethodParameterLineBreak::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstParameterIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::FirstParameterIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::FirstParameterIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::HashAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::HashAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::HashAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::HeredocIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::HeredocIndentation::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Layout::HeredocIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::IndentationConsistency::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationConsistency::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::IndentationConsistency::SPACE -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::IndentationStyle::SPACE -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::IndentationWidth::SPACE -# uninitialized constant RuboCop::Cop::Layout::InitialIndentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::InitialIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::InitialIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::LeadingCommentSpace::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::LeadingCommentSpace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::LeadingCommentSpace::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::LeadingEmptyLines::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::LeadingEmptyLines::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::LineEndStringConcatenationIndentation::SPACE -# uninitialized constant RuboCop::Cop::Layout::LineLength::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::LineLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::LineLength::RESTRICT_ON_SEND -# wrong constant name on_def -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayBraceLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayBraceLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayLineBreaks::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineArrayLineBreaks::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineAssignmentLayout::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::MultilineAssignmentLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineAssignmentLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineBlockLayout::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::MultilineBlockLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineBlockLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineHashBraceLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineHashBraceLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineHashKeyLineBreaks::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks::RESTRICT_ON_SEND -# wrong constant name on_def -# wrong constant name <static-init> -# uninitialized constant RuboCop::Cop::Layout::ParameterAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::ParameterAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::ParameterAlignment::SPACE -# uninitialized constant RuboCop::Cop::Layout::RedundantLineBreak::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::RedundantLineBreak::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::RescueEnsureAlignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::RescueEnsureAlignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::RescueEnsureAlignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SingleLineBlockChain::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SingleLineBlockChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SingleLineBlockChain::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterColon::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterColon::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterMethodName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterMethodName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterMethodName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterNot::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAfterNot::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundKeyword::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundKeyword::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundMethodCallOperator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundOperators::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundOperators::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceAroundOperators::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBlockBraces::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBlockBraces::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBlockBraces::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBrackets::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeBrackets::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeComment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeFirstArg::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeFirstArg::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceBeforeFirstArg::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInLambdaLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInLambdaLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInLambdaLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideParens::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideParens::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideParens::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideRangeLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideRangeLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideReferenceBrackets::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Layout::SpaceInsideStringInterpolation::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Layout::SpaceInsideStringInterpolation::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Layout::TrailingWhitespace::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AmbiguousAssignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::AmbiguousAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AmbiguousBlockAssociation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousBlockAssociation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AmbiguousOperator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousOperator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AmbiguousOperatorPrecedence::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousRange::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousRange::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AmbiguousRegexpLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AmbiguousRegexpLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::AssignmentInCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::AssignmentInCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::BigDecimalNew::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::BooleanSymbol::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::BooleanSymbol::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::CircularArgumentReference::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::CircularArgumentReference::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ConstantDefinitionInBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ConstantDefinitionInBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ConstantOverwrittenInRescue::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ConstantOverwrittenInRescue::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ConstantOverwrittenInRescue::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ConstantResolution::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ConstantResolution::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::Debugger::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::Debugger::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DeprecatedClassMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DeprecatedConstants::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DeprecatedConstants::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateBranch::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateBranch::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateCaseCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateCaseCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateElsifCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateElsifCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateHashKey::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateHashKey::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::DuplicateRequire::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::DuplicateRequire::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateRescueException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::DuplicateRescueException::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EachWithObjectArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ElseLayout::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ElseLayout::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ElseLayout::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyConditionalBody::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::EmptyConditionalBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyConditionalBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyEnsure::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyEnsure::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyExpression::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyExpression::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyFile::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::EmptyFile::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyFile::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyInPattern::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyInPattern::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyInterpolation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EmptyWhen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EmptyWhen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::EnsureReturn::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::EnsureReturn::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::EnsureReturn::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ErbNewArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ErbNewArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::FlipFlop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::FlipFlop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::FloatComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::FloatOutOfRange::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::FloatOutOfRange::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::FormatParameterMismatch::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::HashCompareByIdentity::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::HeredocMethodCallPosition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::HeredocMethodCallPosition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::HeredocMethodCallPosition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::IdentityComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ImplicitStringConcatenation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ImplicitStringConcatenation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::IneffectiveAccessModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::IneffectiveAccessModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::InheritException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::InterpolationCheck::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::InterpolationCheck::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::LambdaWithoutLiteralBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::LiteralAsCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::LiteralAsCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::LiteralAsCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::LiteralInInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::LiteralInInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::LiteralInInterpolation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::Loop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::Loop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::MissingCopEnableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::MissingCopEnableDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::MissingCopEnableDirective::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::MissingSuper::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::MissingSuper::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::MixedRegexpCaptureTypes::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::MixedRegexpCaptureTypes::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::MultipleComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NestedMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NestedMethodDefinition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NestedPercentLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::NestedPercentLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NestedPercentLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NextWithoutAccumulator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NextWithoutAccumulator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NoReturnInBeginEndBlocks::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NonAtomicFileOperation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::NonAtomicFileOperation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NonAtomicFileOperation::SPACE -# uninitialized constant RuboCop::Cop::Lint::NonDeterministicRequireOrder::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NonDeterministicRequireOrder::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NonLocalExitFromIterator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NonLocalExitFromIterator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NumberConversion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NumberConversion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::NumberedParameterAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::NumberedParameterAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::OrAssignmentToConstant::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::OrAssignmentToConstant::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::OrderedMagicComments::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::OutOfRangeRegexpRef::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ParenthesesAsGroupedExpression::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::PercentStringArray::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::PercentStringArray::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::PercentStringArray::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::PercentSymbolArray::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::PercentSymbolArray::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::PercentSymbolArray::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RaiseException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RandOne::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantCopDisableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantCopDisableDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantCopDisableDirective::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Lint::RedundantCopEnableDirective::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Lint::RedundantCopEnableDirective::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Lint::RedundantCopEnableDirective::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Lint::RedundantDirGlobSort::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantRequireStatement::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantRequireStatement::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantSafeNavigation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantSafeNavigation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantSafeNavigation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantSplatExpansion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantSplatExpansion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantStringCoercion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantStringCoercion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantWithIndex::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantWithIndex::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantWithIndex::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RedundantWithObject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RedundantWithObject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RedundantWithObject::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RefinementImportMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RegexpAsCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RegexpAsCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RequireParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RequireParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RequireParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RequireRangeParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RequireRangeParentheses::RESTRICT_ON_SEND -# wrong constant name on_erange -# wrong constant name on_irange -# wrong constant name <static-init> -# uninitialized constant RuboCop::Cop::Lint::RequireRelativeSelfPath::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::RequireRelativeSelfPath::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RescueException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RescueException::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::RescueType::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::RescueType::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ReturnInVoidContext::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ReturnInVoidContext::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationChain::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationConsistency::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationConsistency::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationWithEmpty::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SafeNavigationWithEmpty::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ScriptPermission::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ScriptPermission::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SelfAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SelfAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SendWithMixinArgument::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::SendWithMixinArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ShadowedArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ShadowedArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ShadowedException::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::ShadowedException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ShadowedException::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::ShadowingOuterLocalVariable::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ShadowingOuterLocalVariable::RESTRICT_ON_SEND -# wrong constant name find_conditional_node_from_ascendant -# uninitialized constant RuboCop::Cop::Lint::StructNewOverride::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SuppressedException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::SuppressedException::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::SymbolConversion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ToEnumArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ToJSON::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::ToJSON::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::TopLevelReturnWithArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::TopLevelReturnWithArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::TripleQuotes::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::TripleQuotes::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnderscorePrefixedVariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnderscorePrefixedVariableName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnexpectedBlockArity::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnexpectedBlockArity::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnifiedInteger::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnifiedInteger::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnmodifiedReduceAccumulator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnreachableCode::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnreachableCode::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UnreachableLoop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UnreachableLoop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UriEscapeUnescape::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UriRegexp::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessAccessModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::UselessAccessModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessAccessModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UselessAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UselessElseWithoutRescue::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessElseWithoutRescue::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UselessMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessMethodDefinition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UselessRuby2Keywords::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessSetterCall::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::UselessSetterCall::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Lint::UselessTimes::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Lint::UselessTimes::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::Void::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Lint::Void::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::AbcSize::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::AbcSize::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::BlockLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::BlockLength::MSG -# uninitialized constant RuboCop::Cop::Metrics::BlockLength::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::BlockNesting::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::BlockNesting::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::CyclomaticComplexity::KNOWN_ITERATING_METHODS -# uninitialized constant RuboCop::Cop::Metrics::CyclomaticComplexity::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::CyclomaticComplexity::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::MethodLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::MethodLength::MSG -# uninitialized constant RuboCop::Cop::Metrics::MethodLength::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::ParameterLists::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::ParameterLists::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::PerceivedComplexity::KNOWN_ITERATING_METHODS -# uninitialized constant RuboCop::Cop::Metrics::PerceivedComplexity::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Metrics::PerceivedComplexity::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::KNOWN_ITERATING_METHODS -# uninitialized constant RuboCop::Cop::Metrics::Utils::AbcSizeCalculator::VAR_SETTER_TO_GETTER -# uninitialized constant RuboCop::Cop::Migration::DepartmentName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Migration::DepartmentName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Migration::DepartmentName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::AccessorMethodName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::AccessorMethodName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::AsciiIdentifiers::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::AsciiIdentifiers::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::AsciiIdentifiers::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::BinaryOperatorParameterName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::BinaryOperatorParameterName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::BlockForwarding::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::BlockForwarding::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::BlockForwarding::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::ClassAndModuleCamelCase::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::ClassAndModuleCamelCase::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::ConstantName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::ConstantName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::FileName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::FileName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::FileName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterCase::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterCase::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterCase::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterNaming::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterNaming::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Naming::HeredocDelimiterNaming::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::InclusiveLanguage::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::InclusiveLanguage::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::InclusiveLanguage::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::MemoizedInstanceVariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::MemoizedInstanceVariableName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::MethodName::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Naming::MethodName::FORMATS -# uninitialized constant RuboCop::Cop::Naming::MethodName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::MethodName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::RescuedExceptionsVariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::RescuedExceptionsVariableName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::VariableName::FORMATS -# uninitialized constant RuboCop::Cop::Naming::VariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::VariableName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::VariableName::SIGILS -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::FORMATS -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Naming::VariableNumber::SIGILS -# uninitialized constant RuboCop::Cop::Performance::AncestorsInclude::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::AncestorsInclude::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::BigDecimalWithNumericArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::BindCall::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::BindCall::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::BlockGivenWithExplicitBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::Caller::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::Casecmp::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ChainArrayAllocation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ChainArrayAllocation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ChainArrayAllocation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::CollectionLiteralInLoop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::CollectionLiteralInLoop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::ConcurrentMonotonicTime::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ConstantRegexp::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ConstantRegexp::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::Count::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::Count::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::DeletePrefix::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::DeleteSuffix::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::Detect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::EndWith::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::FixedSize::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::FlatMap::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::FlatMap::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::InefficientHashSearch::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::IoReadlines::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::IoReadlines::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::MapCompact::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::MapCompact::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::MethodObjectAsBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::MethodObjectAsBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::OpenStruct::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RangeInclude::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantEqualityComparisonBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::RedundantMatch::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantMerge::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantSortBlock::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::RedundantSortBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantSortBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::RedundantSplitRegexpArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::RedundantStringChars::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::RedundantStringChars::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ReverseEach::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ReverseEach::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::ReverseFirst::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::ReverseFirst::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::SelectMap::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::SelectMap::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::Size::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::SortReverse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::SortReverse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::SortReverse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Performance::Squeeze::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::StartWith::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::StringIdentifierArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::StringInclude::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::StringReplacement::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::StringReplacement::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::Sum::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Performance::Sum::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::TimesMap::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::UnfreezeString::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Performance::UriDefaultParser::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AlignLeftLetBrace::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AlignRightLetBrace::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::AnyInstance::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::AroundBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Be::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Be::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::BeEq::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::BeEql::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::BeNil::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::BeforeAfterAll::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::FeatureMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Capybara::SpecificMatcher::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Capybara::VisibilityMatcher::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ChangeByZero::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ContextMethod::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ContextWording::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribeClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribeMethod::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::DescribeSymbol::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribedClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::DescribedClassModuleWrapping::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Dialect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Dialect::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyExampleGroup::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyHook::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExample::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterHook::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::EmptyLineAfterSubject::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::MSG -# uninitialized constant RuboCop::Cop::RSpec::ExampleLength::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleWithoutDescription::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExampleWording::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectActual::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExpectChange::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectInHook::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ExpectOutput::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::CreateList::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::FactoryClassName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FilePath::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::FilePath::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Focus::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::Focus::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Focus::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::HookArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::HooksBeforeExamples::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::IdenticalEqualityAssertion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitBlockExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ImplicitExpect::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ImplicitSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InstanceSpy::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::InstanceVariable::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ItBehavesLike::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::IteratedExpectation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LeadingSubject::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LeakyConstantDeclaration::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LetBeforeExamples::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::LetSetup::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MessageChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageExpectation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MessageSpies::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MissingExampleGroupArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleDescribes::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleExpectations::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MultipleMemoizedHelpers::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleMemoizedHelpers::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::MultipleSubjects::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::NamedSubject::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::NestedGroups::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::NotToNot::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::OverwritingSetup::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Pending::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Pending::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Rails::AvoidSetupHook::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Rails::AvoidSetupHook::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::Rails::HaveHttpStatus::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Rails::HaveHttpStatus::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ReceiveCounts::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ReceiveNever::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedDescription::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExample::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupBody::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::RepeatedIncludeExample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::RepeatedIncludeExample::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ReturnFromStub::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ScatteredLet::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::ScatteredSetup::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SharedContext::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::SingleArgumentMessageChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::StubbedMock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::StubbedMock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::SubjectDeclaration::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SubjectDeclaration::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::SubjectStub::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::UnspecifiedException::LITERAL_REGEX -# wrong constant name <static-init> -# wrong constant name all -# wrong constant name <static-init> -# wrong constant name all -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VariableDefinition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::VariableName::FORMATS -# uninitialized constant RuboCop::Cop::RSpec::VariableName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VariableName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubleReference::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VerifiedDoubles::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::VoidExpect::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Yield::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::RSpec::Yield::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::RSpec::Yield::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Rake::ClassDefinitionInTask::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Rake::ClassDefinitionInTask::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Rake::Desc::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Rake::Desc::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Rake::DuplicateNamespace::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Rake::DuplicateNamespace::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Rake::DuplicateTask::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Rake::DuplicateTask::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Rake::MethodDefinitionInTask::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Rake::MethodDefinitionInTask::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Security::CompoundHash::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::CompoundHash::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Security::Eval::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::IoMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::JSONLoad::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::MarshalLoad::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::Open::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Security::YAMLLoad::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::CallbackConditionalsBinding::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::CallbackConditionalsBinding::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::EnforceSigilOrder::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Sorbet::EnforceSigilOrder::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::EnforceSigilOrder::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::EnforceSigilOrder::SIGIL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::EnforceSigilOrder::STRICTNESS_LEVELS -# uninitialized constant RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::ForbidUntypedStructProps::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::ForbidUntypedStructProps::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::OneAncestorPerLine::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::OneAncestorPerLine::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::SignatureBuildOrder::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::SignatureBuildOrder::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::TypeAliasName::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::TypeAliasName::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Sorbet::ValidSigil::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Sorbet::ValidSigil::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::SpaceBeforePunctuation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AccessModifierDeclarations::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AccessorGrouping::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AccessorGrouping::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AccessorGrouping::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::AccessorGrouping::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Style::Alias::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AndOr::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AndOr::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AndOr::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ArgumentsForwarding::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ArgumentsForwarding::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ArgumentsForwarding::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ArrayCoercion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ArrayCoercion::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ArrayJoin::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AsciiComments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::AsciiComments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AsciiComments::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Attr::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Attr::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::AutoResourceCleanup::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BarePercentLiterals::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BarePercentLiterals::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::BeginBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BeginBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::BisectedAttrAccessor::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::BisectedAttrAccessor::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BisectedAttrAccessor::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::BlockComments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::BlockComments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BlockComments::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::BlockDelimiters::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::BlockDelimiters::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::BlockDelimiters::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CaseEquality::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CaseLikeIf::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::CaseLikeIf::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CaseLikeIf::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CharacterLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CharacterLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ClassAndModuleChildren::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ClassAndModuleChildren::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ClassAndModuleChildren::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ClassCheck::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ClassEqualityComparison::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ClassEqualityComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ClassMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ClassMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ClassMethodsDefinitions::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ClassMethodsDefinitions::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ClassMethodsDefinitions::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ClassMethodsDefinitions::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Style::ClassVars::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CollectionCompact::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::CollectionCompact::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CollectionMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CollectionMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ColonMethodCall::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ColonMethodCall::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ColonMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ColonMethodDefinition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CombinableLoops::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CombinableLoops::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CommandLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CommandLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CommentAnnotation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::CommentAnnotation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CommentAnnotation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::CommentedKeyword::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::CommentedKeyword::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::CommentedKeyword::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::ALIGN_WITH -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::END_ALIGNMENT -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::EQUAL -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::KEYWORD -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ConditionalAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ConstantVisibility::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ConstantVisibility::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Copyright::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Copyright::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Copyright::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DateTime::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DateTime::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DefWithParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DefWithParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Dir::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DocumentDynamicEvalDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Documentation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Documentation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Documentation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Style::DoubleCopDisableDirective::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::DoubleCopDisableDirective::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::DoubleNegation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EachForSimpleLoop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EachForSimpleLoop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EachWithObject::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EachWithObject::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EachWithObject::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EmptyBlockParameter::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyBlockParameter::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyBlockParameter::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EmptyCaseCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyCaseCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyCaseCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EmptyElse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyElse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyElse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EmptyHeredoc::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyHeredoc::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyHeredoc::OPENING_DELIMITER -# uninitialized constant RuboCop::Cop::Style::EmptyHeredoc::RESTRICT_ON_SEND -# wrong constant name on_heredoc -# wrong constant name <static-init> -# uninitialized constant RuboCop::Cop::Style::EmptyLambdaParameter::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyLambdaParameter::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyLambdaParameter::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::EmptyLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EmptyMethod::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Encoding::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Encoding::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Encoding::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EndBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EndBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EndlessMethod::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EndlessMethod::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::EnvHome::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EvalWithLocation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::EvenOdd::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ExpandPathArguments::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ExpandPathArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ExplicitBlockArgument::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::ExplicitBlockArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ExplicitBlockArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ExponentialNotation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ExponentialNotation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::FetchEnvVar::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FetchEnvVar::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::FileRead::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::FileRead::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FileWrite::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::FileWrite::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FloatDivision::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::For::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::For::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::For::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::FormatString::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FormatStringToken::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FormatStringToken::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::FrozenStringLiteralComment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::GlobalStdStream::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::GlobalStdStream::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::GlobalVars::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::GlobalVars::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::GuardClause::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::GuardClause::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::HashConversion::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::HashEachMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::HashEachMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::HashExcept::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::HashExcept::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::HashLikeCase::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::HashLikeCase::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::HashSyntax::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::HashSyntax::EXPLICIT_HASH_VALUE_MSG -# uninitialized constant RuboCop::Cop::Style::HashSyntax::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::HashSyntax::OMIT_HASH_VALUE_MSG -# uninitialized constant RuboCop::Cop::Style::HashSyntax::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IdenticalConditionalBranches::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::IdenticalConditionalBranches::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IdenticalConditionalBranches::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IfInsideElse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::IfInsideElse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IfInsideElse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IfWithBooleanLiteralBranches::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IfWithBooleanLiteralBranches::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IfWithSemicolon::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IfWithSemicolon::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ImplicitRuntimeError::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::InPatternThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::InPatternThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::InfiniteLoop::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::InfiniteLoop::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::InlineComment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::InlineComment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::InverseMethods::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::InverseMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::InverseMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::IpAddresses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::IpAddresses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::KeywordParametersOrder::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::KeywordParametersOrder::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::KeywordParametersOrder::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Lambda::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Lambda::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::LambdaCall::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::LineEndConcatenation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::LineEndConcatenation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::LineEndConcatenation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MapCompactWithConditionalBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MapCompactWithConditionalBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MapToHash::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MapToHash::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodCallWithArgsParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodCallWithArgsParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MethodCallWithArgsParentheses::TRAILING_WHITESPACE_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MethodCalledOnDoEndBlock::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MethodCalledOnDoEndBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodCalledOnDoEndBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MethodDefParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MethodDefParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MethodDefParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MinMax::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MinMax::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MissingElse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MissingElse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MissingRespondToMissing::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MissingRespondToMissing::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MixinGrouping::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MixinGrouping::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MixinUsage::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ModuleFunction::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ModuleFunction::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineBlockChain::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineBlockChain::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineBlockChain::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineIfModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineIfModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineIfModifier::SPACE -# uninitialized constant RuboCop::Cop::Style::MultilineIfThen::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineIfThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineIfThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineInPatternThen::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineInPatternThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineInPatternThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineMemoization::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineMemoization::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineMethodSignature::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineMethodSignature::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineMethodSignature::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineTernaryOperator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineTernaryOperator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultilineWhenThen::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::MultilineWhenThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultilineWhenThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MultipleComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MultipleComparison::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::MutableConstant::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Style::MutableConstant::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::MutableConstant::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::MutableConstant::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NegatedIfElseCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NegatedIfElseCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NegatedIfElseCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NestedFileDirname::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedFileDirname::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NestedModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NestedModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NestedParenthesizedCalls::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedParenthesizedCalls::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NestedParenthesizedCalls::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NestedTernaryOperator::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NestedTernaryOperator::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NestedTernaryOperator::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Next::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Next::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Next::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NilComparison::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NilLambda::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::NilLambda::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NilLambda::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NonNilCheck::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Not::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Not::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NumberedParameters::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NumberedParameters::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NumberedParametersLimit::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NumberedParametersLimit::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NumericLiteralPrefix::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NumericLiteralPrefix::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NumericLiterals::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::NumericLiterals::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::NumericPredicate::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ObjectThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ObjectThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OneLineConditional::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OneLineConditional::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OpenStructUse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OpenStructUse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OptionHash::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OptionHash::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OptionalArguments::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OptionalArguments::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OptionalBooleanParameter::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OptionalBooleanParameter::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::OrAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::OrAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ParallelAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::PercentQLiterals::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::PercentQLiterals::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::PercentQLiterals::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::PerlBackrefs::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::PerlBackrefs::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::PreferredHashMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Proc::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Proc::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::QuotedSymbols::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::QuotedSymbols::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RaiseArgs::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RandomWithOffset::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantArgument::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantArgument::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantArgument::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantBegin::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantBegin::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantBegin::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantCapitalW::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantCapitalW::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantCapitalW::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantCondition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantConditional::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantConditional::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantConditional::SPACE -# uninitialized constant RuboCop::Cop::Style::RedundantException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantFetchBlock::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantFetchBlock::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Style::RedundantFetchBlock::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::RedundantFetchBlock::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantFetchBlock::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantFileExtensionInRequire::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantFileExtensionInRequire::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::FROZEN_STRING_LITERAL -# Did you mean? RuboCop::Cop::FrozenStringLiteral -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::FROZEN_STRING_LITERAL_ENABLED -# uninitialized constant RuboCop::Cop::Style::RedundantFreeze::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantInitialize::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantInitialize::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantInitialize::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantInterpolation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantInterpolation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantPercentQ::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantPercentQ::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpCharacterClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpCharacterClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpEscape::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpEscape::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantRegexpEscape::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantReturn::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantReturn::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantReturn::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantSelf::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantSelf::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignment::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignmentBranch::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignmentBranch::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantSelfAssignmentBranch::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RedundantSort::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSort::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantSortBy::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RedundantSortBy::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RedundantSortBy::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RegexpLiteral::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RegexpLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RegexpLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RescueModifier::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RescueModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RescueModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::RescueModifier::SPACE -# uninitialized constant RuboCop::Cop::Style::RescueStandardError::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::RescueStandardError::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::RescueStandardError::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::ReturnNil::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ReturnNil::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SafeNavigation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SafeNavigation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SafeNavigation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Sample::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SelectByRegexp::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SelectByRegexp::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SelfAssignment::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SelfAssignment::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Semicolon::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Semicolon::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::Semicolon::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Send::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SignalException::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SingleArgumentDig::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SingleLineBlockParams::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SingleLineBlockParams::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SingleLineMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SingleLineMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SingleLineMethods::SPACE -# uninitialized constant RuboCop::Cop::Style::SlicingWithRange::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SoleNestedConditional::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SoleNestedConditional::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SoleNestedConditional::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SpecialGlobalVars::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SpecialGlobalVars::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SpecialGlobalVars::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::StabbyLambdaParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StabbyLambdaParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::StaticClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StaticClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::StaticClass::VISIBILITY_SCOPES -# uninitialized constant RuboCop::Cop::Style::StderrPuts::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::StderrPuts::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringChars::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::StringChars::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringConcatenation::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::StringConcatenation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringHashKeys::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringHashKeys::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::StringLiterals::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringLiterals::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::StringMethods::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StringMethods::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::Strip::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::Strip::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StructInheritance::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::StructInheritance::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::StructInheritance::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SwapValues::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SwapValues::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SwapValues::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SymbolArray::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SymbolArray::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SymbolLiteral::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SymbolLiteral::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::SymbolProc::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::SymbolProc::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::SymbolProc::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Style::TernaryParentheses::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Style::TernaryParentheses::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Style::TernaryParentheses::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TopLevelMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnClass::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnClass::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnClass::SPACE -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnMethodDefinition::SPACE -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnModule::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnModule::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingBodyOnModule::SPACE -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInBlockArgs::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingCommaInBlockArgs::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingMethodEndStatement::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingMethodEndStatement::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::NO_SPACE_COMMAND -# Did you mean? RuboCop::Cop::Style::TrailingUnderscoreVariable::SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::SINGLE_SPACE_REGEXP -# uninitialized constant RuboCop::Cop::Style::TrailingUnderscoreVariable::SPACE_COMMAND -# Did you mean? RuboCop::Cop::Style::TrailingUnderscoreVariable::NO_SPACE_COMMAND -# uninitialized constant RuboCop::Cop::Style::TrivialAccessors::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::TrivialAccessors::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::UnlessElse::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::UnlessElse::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::UnlessElse::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::UnlessLogicalOperators::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::UnlessLogicalOperators::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::UnpackFirst::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::VariableInterpolation::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::VariableInterpolation::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::WhenThen::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::WhenThen::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::WhileUntilDo::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::WhileUntilDo::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::WhileUntilModifier::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::WhileUntilModifier::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::WordArray::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::WordArray::RESTRICT_ON_SEND -# uninitialized constant RuboCop::Cop::Style::YodaCondition::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::Style::YodaCondition::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::Style::ZeroLengthPredicate::LITERAL_REGEX -# uninitialized constant RuboCop::Cop::SurroundingSpace::BYTE_ORDER_MARK -# uninitialized constant RuboCop::Cop::TrailingComma::BYTE_ORDER_MARK -# wrong constant name single_line? -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name load -# wrong constant name <static-init> -# wrong constant name load -# uninitialized constant RuboCop::Formatter::ClangStyleFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::FuubarStyleFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::FuubarStyleFormatter::ELLIPSES -# uninitialized constant RuboCop::Formatter::PacmanFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::PacmanFormatter::ELLIPSES -# uninitialized constant RuboCop::Formatter::ProgressFormatter::COLOR_FOR_SEVERITY -# uninitialized constant RuboCop::Formatter::ProgressFormatter::ELLIPSES -# uninitialized constant RuboCop::MagicComment::EmacsComment::KEYWORDS -# Did you mean? RuboCop::MagicComment::KEYWORDS -# uninitialized constant RuboCop::MagicComment::EmacsComment::TOKEN -# Did you mean? RuboCop::Token -# RuboCop::MagicComment::TOKEN -# uninitialized constant RuboCop::MagicComment::VimComment::TOKEN -# Did you mean? RuboCop::Token -# RuboCop::MagicComment::TOKEN -# wrong constant name <Class:Compiler> -# wrong constant name <Class:Lexer> -# uninitialized constant RuboCop::TargetRuby::ToolVersionsFile::RUBY_VERSION_FILENAME -# Did you mean? RuboCop::TargetRuby::RubyVersionFile -# uninitialized constant RuboCop::TargetRuby::ToolVersionsFile::RUBY_VERSION_PATTERN -# wrong constant name <Class:TerminateLineInput> -# wrong constant name check_code_block -# wrong constant name check_corresponding_token_depth -# wrong constant name check_newline_depth_difference -# wrong constant name check_state -# wrong constant name check_string_literal -# wrong constant name each_top_level_statement -# wrong constant name initialize_input -# wrong constant name lex -# wrong constant name process_continue -# wrong constant name process_literal_type -# wrong constant name process_nesting_level -# wrong constant name prompt -# wrong constant name ripper_lex_without_warning -# wrong constant name set_auto_indent -# wrong constant name set_input -# wrong constant name set_prompt -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name compile_with_errors_suppressed -# wrong constant name pretty_print_children -# wrong constant name <static-init> -# wrong constant name enabled? -# wrong constant name pause -# wrong constant name resume -# uninitialized constant SDBM -# uninitialized constant SDBM -# uninitialized constant SDBMError -# uninitialized constant SDBMError -# uninitialized constant Scanf -# uninitialized constant Scanf -# wrong constant name == -# wrong constant name === -# wrong constant name divide -# wrong constant name eql? -# wrong constant name flatten_merge -# wrong constant name pretty_print -# wrong constant name pretty_print_cycle -# wrong constant name reset -# uninitialized constant Shell -# uninitialized constant Shell -# wrong constant name _dump -# wrong constant name clone -# wrong constant name dup -# wrong constant name _load -# wrong constant name clone -# wrong constant name __init__ -# uninitialized constant Socket::APPEND -# uninitialized constant Socket::BINARY -# uninitialized constant Socket::CREAT -# uninitialized constant Socket::DSYNC -# Did you mean? Socket::SYNC -# uninitialized constant Socket::EXCL -# uninitialized constant Socket::FNM_CASEFOLD -# uninitialized constant Socket::FNM_DOTMATCH -# uninitialized constant Socket::FNM_EXTGLOB -# uninitialized constant Socket::FNM_NOESCAPE -# uninitialized constant Socket::FNM_PATHNAME -# uninitialized constant Socket::FNM_SHORTNAME -# uninitialized constant Socket::FNM_SYSCASE -# uninitialized constant Socket::LOCK_EX -# Did you mean? Socket::LOCK_NB -# Socket::LOCK_UN -# Socket::LOCK_SH -# uninitialized constant Socket::LOCK_NB -# Did you mean? Socket::LOCK_UN -# Socket::LOCK_EX -# Socket::LOCK_SH -# uninitialized constant Socket::LOCK_SH -# Did you mean? Socket::LOCK_NB -# Socket::LOCK_UN -# Socket::LOCK_EX -# uninitialized constant Socket::LOCK_UN -# Did you mean? Socket::LOCK_NB -# Socket::LOCK_EX -# Socket::LOCK_SH -# uninitialized constant Socket::NOCTTY -# uninitialized constant Socket::NOFOLLOW -# uninitialized constant Socket::NONBLOCK -# uninitialized constant Socket::NULL -# uninitialized constant Socket::RDONLY -# Did you mean? Socket::WRONLY -# uninitialized constant Socket::RDWR -# uninitialized constant Socket::SEEK_CUR -# uninitialized constant Socket::SEEK_DATA -# Did you mean? Socket::SEEK_SET -# uninitialized constant Socket::SEEK_END -# uninitialized constant Socket::SEEK_HOLE -# uninitialized constant Socket::SEEK_SET -# uninitialized constant Socket::SHARE_DELETE -# uninitialized constant Socket::SYNC -# Did you mean? Socket::DSYNC -# uninitialized constant Socket::TRUNC -# Did you mean? TRUE -# uninitialized constant Socket::WRONLY -# Did you mean? Socket::RDONLY -# wrong constant name shellescape -# wrong constant name shellsplit -# wrong constant name set_encoding_by_bom -# wrong constant name bol? -# wrong constant name fixed_anchor? -# wrong constant name initialize -# wrong constant name deconstruct -# wrong constant name deconstruct_keys -# wrong constant name filter -# wrong constant name <Class:Struct> -# uninitialized constant Sync -# uninitialized constant Sync -# uninitialized constant Sync_m -# uninitialized constant Sync_m -# uninitialized constant Syslog -# uninitialized constant Syslog -# wrong constant name T.noreturn -# wrong constant name T.noreturn -# wrong constant name T.untyped -# wrong constant name <Class:Remover> -# wrong constant name _close -# wrong constant name call -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <Class:RakeCompat> -# uninitialized constant Thor::SHELL_DELEGATED_METHODS -# uninitialized constant Thor::Options::NUMERIC -# Did you mean? Numeric -# uninitialized constant Thor::RakeCompat::DEFAULT -# uninitialized constant Thor::RakeCompat::LN_SUPPORTED -# uninitialized constant Thor::RakeCompat::LOW_METHODS -# Did you mean? Thor::RakeCompat::LowMethods -# uninitialized constant Thor::RakeCompat::METHODS -# Did you mean? Method -# uninitialized constant Thor::RakeCompat::OPT_TABLE -# uninitialized constant Thor::RakeCompat::RUBY -# uninitialized constant Thor::RakeCompat::VERSION -# wrong constant name <static-init> -# wrong constant name included -# wrong constant name rake_classes -# wrong constant name <Class:Basic> -# wrong constant name <Class:Color> -# wrong constant name <Class:HTML> -# wrong constant name answer_match -# wrong constant name as_unicode -# wrong constant name ask -# wrong constant name ask_filtered -# wrong constant name ask_simply -# wrong constant name base -# wrong constant name base= -# wrong constant name can_display_colors? -# wrong constant name dynamic_width -# wrong constant name dynamic_width_stty -# wrong constant name dynamic_width_tput -# wrong constant name error -# wrong constant name file_collision -# wrong constant name file_collision_help -# wrong constant name git_merge_tool -# wrong constant name indent -# wrong constant name is? -# wrong constant name lookup_color -# wrong constant name merge -# wrong constant name merge_tool -# wrong constant name mute -# wrong constant name mute? -# wrong constant name no? -# wrong constant name padding -# wrong constant name padding= -# wrong constant name prepare_message -# wrong constant name print_in_columns -# wrong constant name print_table -# wrong constant name print_wrapped -# wrong constant name quiet? -# wrong constant name say -# wrong constant name say_error -# wrong constant name say_status -# wrong constant name set_color -# wrong constant name show_diff -# wrong constant name stderr -# wrong constant name stdout -# wrong constant name terminal_width -# wrong constant name truncate -# wrong constant name unix? -# wrong constant name yes? -# wrong constant name <static-init> -# uninitialized constant Thor::Shell::Color::DEFAULT_TERMINAL_WIDTH -# wrong constant name are_colors_disabled? -# wrong constant name are_colors_supported? -# wrong constant name diff_lcs_loaded? -# wrong constant name output_diff_line -# wrong constant name set_color -# wrong constant name <static-init> -# uninitialized constant Thor::Shell::HTML::DEFAULT_TERMINAL_WIDTH -# wrong constant name ask -# wrong constant name diff_lcs_loaded? -# wrong constant name output_diff_line -# wrong constant name set_color -# wrong constant name <static-init> -# uninitialized constant ThreadsWait -# uninitialized constant ThreadsWait -# wrong constant name eval_script -# wrong constant name instruction_sequence -# wrong constant name parameters -# wrong constant name new -# uninitialized constant Tracer -# Did you mean? TracePoint -# uninitialized constant Tracer -# Did you mean? TracePoint -# wrong constant name <Class:File> -# wrong constant name buffer_open -# wrong constant name new2 -# uninitialized constant URI::File::ABS_PATH -# Did you mean? URI::ABS_PATH -# uninitialized constant URI::File::ABS_URI -# Did you mean? URI::ABS_URI -# uninitialized constant URI::File::ABS_URI_REF -# Did you mean? URI::ABS_URI_REF -# uninitialized constant URI::File::DEFAULT_PARSER -# Did you mean? URI::File::DEFAULT_PORT -# URI::DEFAULT_PARSER -# uninitialized constant URI::File::ESCAPED -# Did you mean? URI::File::Escape -# URI::Escape -# URI::ESCAPED -# uninitialized constant URI::File::FRAGMENT -# Did you mean? URI::FRAGMENT -# uninitialized constant URI::File::HOST -# Did you mean? URI::HOST -# uninitialized constant URI::File::OPAQUE -# Did you mean? URI::OPAQUE -# uninitialized constant URI::File::PORT -# Did you mean? URI::PORT -# uninitialized constant URI::File::QUERY -# Did you mean? URI::QUERY -# uninitialized constant URI::File::REGISTRY -# Did you mean? URI::REGISTRY -# uninitialized constant URI::File::REL_PATH -# Did you mean? URI::REL_PATH -# uninitialized constant URI::File::REL_URI -# Did you mean? URI::REL_URI -# uninitialized constant URI::File::REL_URI_REF -# Did you mean? URI::REL_URI_REF -# uninitialized constant URI::File::RFC3986_PARSER -# Did you mean? URI::File::RFC3986_Parser -# URI::RFC3986_Parser -# URI::RFC2396_Parser -# URI::File::RFC2396_Parser -# URI::RFC3986_PARSER -# uninitialized constant URI::File::SCHEME -# Did you mean? URI::SCHEME -# uninitialized constant URI::File::TBLDECWWWCOMP_ -# Did you mean? URI::File::TBLENCWWWCOMP_ -# URI::TBLDECWWWCOMP_ -# URI::TBLENCWWWCOMP_ -# uninitialized constant URI::File::TBLENCWWWCOMP_ -# Did you mean? URI::File::TBLDECWWWCOMP_ -# URI::TBLDECWWWCOMP_ -# URI::TBLENCWWWCOMP_ -# uninitialized constant URI::File::UNSAFE -# Did you mean? URI::UNSAFE -# uninitialized constant URI::File::URI_REF -# Did you mean? URI::URI_REF -# uninitialized constant URI::File::USERINFO -# Did you mean? URI::USERINFO -# uninitialized constant URI::File::USE_REGISTRY -# uninitialized constant URI::File::VERSION -# Did you mean? URI::VERSION -# uninitialized constant URI::File::VERSION_CODE -# Did you mean? URI::VERSION_CODE -# uninitialized constant URI::File::WEB_ENCODINGS_ -# Did you mean? URI::WEB_ENCODINGS_ -# wrong constant name check_password -# wrong constant name check_user -# wrong constant name check_userinfo -# wrong constant name set_userinfo -# wrong constant name <static-init> -# wrong constant name buffer_open -# wrong constant name attributes -# wrong constant name attributes= -# wrong constant name dn -# wrong constant name dn= -# wrong constant name extensions -# wrong constant name extensions= -# wrong constant name filter -# wrong constant name filter= -# wrong constant name initialize -# wrong constant name scope -# wrong constant name scope= -# wrong constant name set_attributes -# wrong constant name set_dn -# wrong constant name set_extensions -# wrong constant name set_filter -# wrong constant name set_scope -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name join -# wrong constant name parse -# wrong constant name regexp -# wrong constant name split -# wrong constant name make_components_hash -# wrong constant name get_encoding -# wrong constant name open -# wrong constant name <static-init> -# uninitialized constant Vector -# uninitialized constant Vector -# uninitialized constant WeakRef -# uninitialized constant WeakRef -# wrong constant name <Class:GemIndex> -# wrong constant name <Class:RegistryResolver> -# wrong constant name <Class:RegistryStore> -# wrong constant name <Class:StubProxy> -# wrong constant name <Class:Verifier> -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name commands -# wrong constant name commands= -# wrong constant name default_command -# wrong constant name default_command= -# wrong constant name run -# wrong constant name append -# wrong constant name append= -# wrong constant name as_list -# wrong constant name as_list= -# wrong constant name gem_install_cmd -# wrong constant name gem_install_cmd= -# wrong constant name key -# wrong constant name key= -# wrong constant name reset -# wrong constant name reset= -# wrong constant name run -# wrong constant name values -# wrong constant name values= -# wrong constant name <static-init> -# wrong constant name run -# wrong constant name <static-init> -# uninitialized constant YARD::CLI::Display::DEFAULT_YARDOPTS_FILE -# wrong constant name format_objects -# wrong constant name initialize -# wrong constant name wrap_layout -# wrong constant name <static-init> -# wrong constant name run -# wrong constant name <static-init> -# uninitialized constant YARD::CLI::Graph::DEFAULT_YARDOPTS_FILE -# wrong constant name objects -# wrong constant name options -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name run -# wrong constant name <static-init> -# uninitialized constant YARD::CLI::I18n::DEFAULT_YARDOPTS_FILE -# wrong constant name <static-init> -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name adapter -# wrong constant name adapter= -# wrong constant name libraries -# wrong constant name libraries= -# wrong constant name options -# wrong constant name options= -# wrong constant name run -# wrong constant name scripts -# wrong constant name scripts= -# wrong constant name server_options -# wrong constant name server_options= -# wrong constant name template_paths -# wrong constant name template_paths= -# wrong constant name <static-init> -# uninitialized constant YARD::CLI::Stats::DEFAULT_YARDOPTS_FILE -# wrong constant name initialize -# wrong constant name output -# wrong constant name parse -# wrong constant name parse= -# wrong constant name print_statistics -# wrong constant name print_undocumented_objects -# wrong constant name stats_for_attributes -# wrong constant name stats_for_classes -# wrong constant name stats_for_constants -# wrong constant name stats_for_files -# wrong constant name stats_for_methods -# wrong constant name stats_for_modules -# wrong constant name <static-init> -# wrong constant name cache_object -# wrong constant name find_object -# wrong constant name print_object -# wrong constant name print_usage -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name all -# wrong constant name each -# wrong constant name find_all_by_name -# uninitialized constant YARD::Handlers::C::AliasHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::AliasHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::AliasHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::AliasHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::AliasHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::AliasHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::AliasHandler::CSEP -# Did you mean? YARD::Handlers::C::AliasHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::CSEPQ -# Did you mean? YARD::Handlers::C::AliasHandler::ISEPQ -# YARD::Handlers::C::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::AliasHandler::ISEP -# Did you mean? YARD::Handlers::C::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::ISEPQ -# Did you mean? YARD::Handlers::C::AliasHandler::CSEPQ -# YARD::Handlers::C::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::AliasHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::AliasHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::AliasHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::AliasHandler::NSEP -# Did you mean? YARD::Handlers::C::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::NSEPQ -# Did you mean? YARD::Handlers::C::AliasHandler::CSEPQ -# YARD::Handlers::C::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::AliasHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::AttributeHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::AttributeHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::AttributeHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::AttributeHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::AttributeHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::AttributeHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::AttributeHandler::CSEP -# Did you mean? YARD::Handlers::C::AttributeHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::CSEPQ -# Did you mean? YARD::Handlers::C::AttributeHandler::ISEPQ -# YARD::Handlers::C::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::AttributeHandler::ISEP -# Did you mean? YARD::Handlers::C::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::ISEPQ -# Did you mean? YARD::Handlers::C::AttributeHandler::CSEPQ -# YARD::Handlers::C::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::AttributeHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::AttributeHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::AttributeHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::AttributeHandler::NSEP -# Did you mean? YARD::Handlers::C::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::NSEPQ -# Did you mean? YARD::Handlers::C::AttributeHandler::CSEPQ -# YARD::Handlers::C::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::AttributeHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::Base::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::Base::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::Base::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::Base::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::Base::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::Base::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::Base::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::Base::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::Base::CSEP -# Did you mean? YARD::Handlers::C::Base::CSEPQ -# uninitialized constant YARD::Handlers::C::Base::CSEPQ -# Did you mean? YARD::Handlers::C::Base::ISEPQ -# YARD::Handlers::C::Base::NSEPQ -# uninitialized constant YARD::Handlers::C::Base::ISEP -# Did you mean? YARD::Handlers::C::Base::ISEPQ -# uninitialized constant YARD::Handlers::C::Base::ISEPQ -# Did you mean? YARD::Handlers::C::Base::CSEPQ -# YARD::Handlers::C::Base::NSEPQ -# uninitialized constant YARD::Handlers::C::Base::METHODMATCH -# uninitialized constant YARD::Handlers::C::Base::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::Base::METHODMATCH -# uninitialized constant YARD::Handlers::C::Base::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::Base::NamespaceMapper -# uninitialized constant YARD::Handlers::C::Base::NSEP -# Did you mean? YARD::Handlers::C::Base::NSEPQ -# uninitialized constant YARD::Handlers::C::Base::NSEPQ -# Did you mean? YARD::Handlers::C::Base::CSEPQ -# YARD::Handlers::C::Base::ISEPQ -# uninitialized constant YARD::Handlers::C::Base::PROXY_MATCH -# wrong constant name ensure_variable_defined! -# wrong constant name namespace_for_variable -# wrong constant name namespaces -# wrong constant name override_comments -# wrong constant name parse_block -# wrong constant name process_file -# wrong constant name processed_files -# wrong constant name symbols -# wrong constant name <static-init> -# wrong constant name handles? -# wrong constant name statement_class -# uninitialized constant YARD::Handlers::C::ClassHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::ClassHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::ClassHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ClassHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::ClassHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::ClassHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::ClassHandler::CSEP -# Did you mean? YARD::Handlers::C::ClassHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::CSEPQ -# Did you mean? YARD::Handlers::C::ClassHandler::ISEPQ -# YARD::Handlers::C::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::ClassHandler::ISEP -# Did you mean? YARD::Handlers::C::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::ISEPQ -# Did you mean? YARD::Handlers::C::ClassHandler::CSEPQ -# YARD::Handlers::C::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ClassHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ClassHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::ClassHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::ClassHandler::NSEP -# Did you mean? YARD::Handlers::C::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::NSEPQ -# Did you mean? YARD::Handlers::C::ClassHandler::CSEPQ -# YARD::Handlers::C::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ClassHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::ConstantHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::ConstantHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::ConstantHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ConstantHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::ConstantHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::ConstantHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::ConstantHandler::CSEP -# Did you mean? YARD::Handlers::C::ConstantHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::CSEPQ -# Did you mean? YARD::Handlers::C::ConstantHandler::ISEPQ -# YARD::Handlers::C::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::ConstantHandler::ISEP -# Did you mean? YARD::Handlers::C::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::ISEPQ -# Did you mean? YARD::Handlers::C::ConstantHandler::CSEPQ -# YARD::Handlers::C::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ConstantHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ConstantHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::ConstantHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::ConstantHandler::NSEP -# Did you mean? YARD::Handlers::C::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::NSEPQ -# Did you mean? YARD::Handlers::C::ConstantHandler::CSEPQ -# YARD::Handlers::C::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ConstantHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::HandlerMethods::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::HandlerMethods::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::HandlerMethods::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::HandlerMethods::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::HandlerMethods::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::HandlerMethods::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::HandlerMethods::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::HandlerMethods::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::HandlerMethods::CSEP -# Did you mean? YARD::Handlers::C::HandlerMethods::CSEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::CSEPQ -# Did you mean? YARD::Handlers::C::HandlerMethods::ISEPQ -# YARD::Handlers::C::HandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::ISEP -# Did you mean? YARD::Handlers::C::HandlerMethods::ISEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::ISEPQ -# Did you mean? YARD::Handlers::C::HandlerMethods::CSEPQ -# YARD::Handlers::C::HandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::METHODMATCH -# uninitialized constant YARD::Handlers::C::HandlerMethods::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::HandlerMethods::METHODMATCH -# uninitialized constant YARD::Handlers::C::HandlerMethods::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::HandlerMethods::NamespaceMapper -# uninitialized constant YARD::Handlers::C::HandlerMethods::NSEP -# Did you mean? YARD::Handlers::C::HandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::NSEPQ -# Did you mean? YARD::Handlers::C::HandlerMethods::CSEPQ -# YARD::Handlers::C::HandlerMethods::ISEPQ -# uninitialized constant YARD::Handlers::C::HandlerMethods::PROXY_MATCH -# wrong constant name handle_alias -# wrong constant name handle_attribute -# wrong constant name handle_class -# wrong constant name handle_constants -# wrong constant name handle_method -# wrong constant name handle_module -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::InitHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::InitHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::InitHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::InitHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::InitHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::InitHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::InitHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::InitHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::InitHandler::CSEP -# Did you mean? YARD::Handlers::C::InitHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::CSEPQ -# Did you mean? YARD::Handlers::C::InitHandler::ISEPQ -# YARD::Handlers::C::InitHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::InitHandler::ISEP -# Did you mean? YARD::Handlers::C::InitHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::ISEPQ -# Did you mean? YARD::Handlers::C::InitHandler::CSEPQ -# YARD::Handlers::C::InitHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::InitHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::InitHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::InitHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::InitHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::InitHandler::NSEP -# Did you mean? YARD::Handlers::C::InitHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::NSEPQ -# Did you mean? YARD::Handlers::C::InitHandler::CSEPQ -# YARD::Handlers::C::InitHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::InitHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::MethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::MethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::MethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::MethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::MethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::MethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::MethodHandler::CSEP -# Did you mean? YARD::Handlers::C::MethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::CSEPQ -# Did you mean? YARD::Handlers::C::MethodHandler::ISEPQ -# YARD::Handlers::C::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::MethodHandler::ISEP -# Did you mean? YARD::Handlers::C::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::ISEPQ -# Did you mean? YARD::Handlers::C::MethodHandler::CSEPQ -# YARD::Handlers::C::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::MethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::MethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::MethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::MethodHandler::NSEP -# Did you mean? YARD::Handlers::C::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::NSEPQ -# Did you mean? YARD::Handlers::C::MethodHandler::CSEPQ -# YARD::Handlers::C::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::MethodHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::MixinHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::MixinHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::MixinHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::MixinHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::MixinHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::MixinHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::MixinHandler::CSEP -# Did you mean? YARD::Handlers::C::MixinHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::CSEPQ -# Did you mean? YARD::Handlers::C::MixinHandler::ISEPQ -# YARD::Handlers::C::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::MixinHandler::ISEP -# Did you mean? YARD::Handlers::C::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::ISEPQ -# Did you mean? YARD::Handlers::C::MixinHandler::CSEPQ -# YARD::Handlers::C::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::MixinHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::MixinHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::MixinHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::MixinHandler::NSEP -# Did you mean? YARD::Handlers::C::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::NSEPQ -# Did you mean? YARD::Handlers::C::MixinHandler::CSEPQ -# YARD::Handlers::C::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::MixinHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::ModuleHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::ModuleHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::ModuleHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::ModuleHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::ModuleHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::ModuleHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::ModuleHandler::CSEP -# Did you mean? YARD::Handlers::C::ModuleHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::CSEPQ -# Did you mean? YARD::Handlers::C::ModuleHandler::ISEPQ -# YARD::Handlers::C::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::ModuleHandler::ISEP -# Did you mean? YARD::Handlers::C::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::ISEPQ -# Did you mean? YARD::Handlers::C::ModuleHandler::CSEPQ -# YARD::Handlers::C::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ModuleHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::ModuleHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::ModuleHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::ModuleHandler::NSEP -# Did you mean? YARD::Handlers::C::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::NSEPQ -# Did you mean? YARD::Handlers::C::ModuleHandler::CSEPQ -# YARD::Handlers::C::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::ModuleHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::CSEP -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::CSEPQ -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::ISEPQ -# YARD::Handlers::C::OverrideCommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::ISEP -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::ISEPQ -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::CSEPQ -# YARD::Handlers::C::OverrideCommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::NSEP -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::NSEPQ -# Did you mean? YARD::Handlers::C::OverrideCommentHandler::CSEPQ -# YARD::Handlers::C::OverrideCommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::PathHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::PathHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::PathHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::PathHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::PathHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::PathHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::PathHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::PathHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::PathHandler::CSEP -# Did you mean? YARD::Handlers::C::PathHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::CSEPQ -# Did you mean? YARD::Handlers::C::PathHandler::ISEPQ -# YARD::Handlers::C::PathHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::PathHandler::ISEP -# Did you mean? YARD::Handlers::C::PathHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::ISEPQ -# Did you mean? YARD::Handlers::C::PathHandler::CSEPQ -# YARD::Handlers::C::PathHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::PathHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::PathHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::PathHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::PathHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::PathHandler::NSEP -# Did you mean? YARD::Handlers::C::PathHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::NSEPQ -# Did you mean? YARD::Handlers::C::PathHandler::CSEPQ -# YARD::Handlers::C::PathHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::PathHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::StructHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::StructHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::StructHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::StructHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::StructHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::StructHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::StructHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::StructHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::StructHandler::CSEP -# Did you mean? YARD::Handlers::C::StructHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::CSEPQ -# Did you mean? YARD::Handlers::C::StructHandler::ISEPQ -# YARD::Handlers::C::StructHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::StructHandler::ISEP -# Did you mean? YARD::Handlers::C::StructHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::ISEPQ -# Did you mean? YARD::Handlers::C::StructHandler::CSEPQ -# YARD::Handlers::C::StructHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::StructHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::StructHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::StructHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::StructHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::StructHandler::NSEP -# Did you mean? YARD::Handlers::C::StructHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::NSEPQ -# Did you mean? YARD::Handlers::C::StructHandler::CSEPQ -# YARD::Handlers::C::StructHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::StructHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::C::SymbolHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::C::SymbolHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::C::SymbolHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::C::SymbolHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::SymbolHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::C::SymbolHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::C::SymbolHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::C::SymbolHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::C::SymbolHandler::CSEP -# Did you mean? YARD::Handlers::C::SymbolHandler::CSEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::CSEPQ -# Did you mean? YARD::Handlers::C::SymbolHandler::ISEPQ -# YARD::Handlers::C::SymbolHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::ERROR_CLASS_NAMES -# uninitialized constant YARD::Handlers::C::SymbolHandler::ISEP -# Did you mean? YARD::Handlers::C::SymbolHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::ISEPQ -# Did you mean? YARD::Handlers::C::SymbolHandler::CSEPQ -# YARD::Handlers::C::SymbolHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::SymbolHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::C::SymbolHandler::METHODMATCH -# uninitialized constant YARD::Handlers::C::SymbolHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::C::SymbolHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::C::SymbolHandler::NSEP -# Did you mean? YARD::Handlers::C::SymbolHandler::NSEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::NSEPQ -# Did you mean? YARD::Handlers::C::SymbolHandler::CSEPQ -# YARD::Handlers::C::SymbolHandler::ISEPQ -# uninitialized constant YARD::Handlers::C::SymbolHandler::PROXY_MATCH -# wrong constant name <static-init> -# wrong constant name add_predicate_return_tag -# wrong constant name <static-init> -# wrong constant name extra_state -# wrong constant name extra_state= -# wrong constant name file -# wrong constant name file= -# wrong constant name find_handlers -# wrong constant name globals -# wrong constant name globals= -# wrong constant name initialize -# wrong constant name namespace -# wrong constant name namespace= -# wrong constant name owner -# wrong constant name owner= -# wrong constant name parse_remaining_files -# wrong constant name parser_type -# wrong constant name parser_type= -# wrong constant name process -# wrong constant name scope -# wrong constant name scope= -# wrong constant name visibility -# wrong constant name visibility= -# wrong constant name <static-init> -# wrong constant name namespace_for_handler -# wrong constant name register_handler_namespace -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::AliasHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::AliasHandler::ISEPQ -# YARD::Handlers::Ruby::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::AliasHandler::CSEPQ -# YARD::Handlers::Ruby::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::AliasHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::AliasHandler::CSEPQ -# YARD::Handlers::Ruby::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::AliasHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::ISEPQ -# YARD::Handlers::Ruby::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::CSEPQ -# YARD::Handlers::Ruby::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::AttributeHandler::CSEPQ -# YARD::Handlers::Ruby::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::AttributeHandler::PROXY_MATCH -# wrong constant name validated_attribute_names -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::ISEPQ -# YARD::Handlers::Ruby::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ -# YARD::Handlers::Ruby::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ -# YARD::Handlers::Ruby::ClassConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassConditionHandler::PROXY_MATCH -# wrong constant name parse_condition -# wrong constant name parse_else_block -# wrong constant name parse_then_block -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ClassHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassHandler::ISEPQ -# YARD::Handlers::Ruby::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ClassHandler::CSEPQ -# YARD::Handlers::Ruby::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassHandler::CSEPQ -# YARD::Handlers::Ruby::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::ISEPQ -# YARD::Handlers::Ruby::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ -# YARD::Handlers::Ruby::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ -# YARD::Handlers::Ruby::ClassVariableHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::CommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::CommentHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::CommentHandler::ISEPQ -# YARD::Handlers::Ruby::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::CommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::CommentHandler::CSEPQ -# YARD::Handlers::Ruby::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::CommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::CommentHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::CommentHandler::CSEPQ -# YARD::Handlers::Ruby::CommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::CommentHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::ISEPQ -# YARD::Handlers::Ruby::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::CSEPQ -# YARD::Handlers::Ruby::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ConstantHandler::CSEPQ -# YARD::Handlers::Ruby::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::DSLHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::DSLHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandler::ISEPQ -# YARD::Handlers::Ruby::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::IGNORE_METHODS -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::DSLHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandler::CSEPQ -# YARD::Handlers::Ruby::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::DSLHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::DSLHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandler::CSEPQ -# YARD::Handlers::Ruby::DSLHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::CSEP -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::ISEPQ -# YARD::Handlers::Ruby::DSLHandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::ISEP -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::ISEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ -# YARD::Handlers::Ruby::DSLHandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::NSEP -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::NSEPQ -# Did you mean? YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ -# YARD::Handlers::Ruby::DSLHandlerMethods::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::PROXY_MATCH -# wrong constant name handle_comments -# wrong constant name register_docstring -# wrong constant name <static-init> -# wrong constant name process_decorator -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::ISEPQ -# YARD::Handlers::Ruby::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::CSEPQ -# YARD::Handlers::Ruby::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ExceptionHandler::CSEPQ -# YARD::Handlers::Ruby::ExceptionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::ISEPQ -# YARD::Handlers::Ruby::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::CSEPQ -# YARD::Handlers::Ruby::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ExtendHandler::CSEPQ -# YARD::Handlers::Ruby::ExtendHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::AliasHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::AliasHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::AttributeHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::AttributeHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::ISEPQ -# YARD::Handlers::Ruby::Legacy::Base::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::CSEPQ -# YARD::Handlers::Ruby::Legacy::Base::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::Base::CSEPQ -# YARD::Handlers::Ruby::Legacy::Base::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::Base::TokenDefinitions -# wrong constant name parse_block -# wrong constant name <static-init> -# wrong constant name handles? -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassConditionHandler::TokenDefinitions -# wrong constant name parse_condition -# wrong constant name parse_else_block -# wrong constant name parse_then_block -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ClassVariableHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ClassVariableHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::CommentHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::CommentHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ConstantHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::IGNORE_METHODS -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::DSLHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::DSLHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ExceptionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExceptionHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ExtendHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ExtendHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::MethodHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::MixinHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::ModuleHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::VisibilityHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::VisibilityHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::ISEPQ -# YARD::Handlers::Ruby::Legacy::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_ARG -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_BEG -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_BEG -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_ARG -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_CLASS -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_DOT -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_END -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_MID -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_FNAME -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_MID -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::EXPR_END -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::NEWLINE_TOKEN -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ -# YARD::Handlers::Ruby::Legacy::YieldHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::TkReading2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::TkSymbol2Token -# uninitialized constant YARD::Handlers::Ruby::Legacy::YieldHandler::TokenDefinitions -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::ISEPQ -# YARD::Handlers::Ruby::MethodConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ -# YARD::Handlers::Ruby::MethodConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ -# YARD::Handlers::Ruby::MethodConditionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::MethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::MethodHandler::ISEPQ -# YARD::Handlers::Ruby::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::MethodHandler::CSEPQ -# YARD::Handlers::Ruby::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::MethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::MethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::MethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::MethodHandler::CSEPQ -# YARD::Handlers::Ruby::MethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MethodHandler::PROXY_MATCH -# wrong constant name format_args -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::MixinHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::MixinHandler::ISEPQ -# YARD::Handlers::Ruby::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::MixinHandler::CSEPQ -# YARD::Handlers::Ruby::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::MixinHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::MixinHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::MixinHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::MixinHandler::CSEPQ -# YARD::Handlers::Ruby::MixinHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::MixinHandler::PROXY_MATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::ISEPQ -# YARD::Handlers::Ruby::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ -# YARD::Handlers::Ruby::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ -# YARD::Handlers::Ruby::ModuleFunctionHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::PROXY_MATCH -# wrong constant name make_module_function -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::ISEPQ -# YARD::Handlers::Ruby::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::CSEPQ -# YARD::Handlers::Ruby::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::ModuleHandler::CSEPQ -# YARD::Handlers::Ruby::ModuleHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::ISEPQ -# YARD::Handlers::Ruby::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::PrivateClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::ISEPQ -# YARD::Handlers::Ruby::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ -# YARD::Handlers::Ruby::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ -# YARD::Handlers::Ruby::PrivateConstantHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::ISEPQ -# YARD::Handlers::Ruby::PublicClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::PublicClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ -# YARD::Handlers::Ruby::PublicClassMethodHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::ISEPQ -# YARD::Handlers::Ruby::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::CSEPQ -# YARD::Handlers::Ruby::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::VisibilityHandler::CSEPQ -# YARD::Handlers::Ruby::VisibilityHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::PROXY_MATCH -# wrong constant name <static-init> -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::BUILTIN_ALL -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::BUILTIN_CLASSES -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Handlers::Ruby::YieldHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::BUILTIN_MODULES -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::CONSTANTMATCH -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::CONSTANTSTART -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::CSEP -# Did you mean? YARD::Handlers::Ruby::YieldHandler::CSEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::CSEPQ -# Did you mean? YARD::Handlers::Ruby::YieldHandler::ISEPQ -# YARD::Handlers::Ruby::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::ISEP -# Did you mean? YARD::Handlers::Ruby::YieldHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::ISEPQ -# Did you mean? YARD::Handlers::Ruby::YieldHandler::CSEPQ -# YARD::Handlers::Ruby::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::METHODNAMEMATCH -# Did you mean? YARD::Handlers::Ruby::YieldHandler::METHODMATCH -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::NAMESPACEMATCH -# Did you mean? YARD::Handlers::Ruby::YieldHandler::NamespaceMapper -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::NSEP -# Did you mean? YARD::Handlers::Ruby::YieldHandler::NSEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::NSEPQ -# Did you mean? YARD::Handlers::Ruby::YieldHandler::CSEPQ -# YARD::Handlers::Ruby::YieldHandler::ISEPQ -# uninitialized constant YARD::Handlers::Ruby::YieldHandler::PROXY_MATCH -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name load -# wrong constant name name -# wrong constant name translate -# wrong constant name <static-init> -# wrong constant name default -# wrong constant name default= -# wrong constant name == -# wrong constant name add_comment -# wrong constant name add_location -# wrong constant name comments -# wrong constant name id -# wrong constant name initialize -# wrong constant name locations -# wrong constant name <static-init> -# wrong constant name == -# uninitialized constant YARD::I18n::Messages::Elem -# wrong constant name [] -# wrong constant name each -# wrong constant name messages -# wrong constant name register -# wrong constant name <static-init> -# wrong constant name generate -# wrong constant name initialize -# wrong constant name messages -# wrong constant name parse_files -# wrong constant name parse_objects -# wrong constant name <static-init> -# wrong constant name extract_messages -# wrong constant name initialize -# wrong constant name translate -# wrong constant name <static-init> -# uninitialized constant YARD::Logger::DEBUG -# uninitialized constant YARD::Logger::ERROR -# Did you mean? YARD::Logger::Error -# IOError -# Errno -# uninitialized constant YARD::Logger::FATAL -# uninitialized constant YARD::Logger::INFO -# uninitialized constant YARD::Logger::ProgName -# uninitialized constant YARD::Logger::SEV_LABEL -# uninitialized constant YARD::Logger::UNKNOWN -# uninitialized constant YARD::Logger::VERSION -# Did you mean? YARD::VERSION -# uninitialized constant YARD::Logger::WARN -# wrong constant name set_token_position -# wrong constant name <static-init> -# wrong constant name def_token -# uninitialized constant YARD::Rake::YardocTask::DEFAULT -# uninitialized constant YARD::Rake::YardocTask::LN_SUPPORTED -# uninitialized constant YARD::Rake::YardocTask::LOW_METHODS -# Did you mean? YARD::Rake::YardocTask::LowMethods -# uninitialized constant YARD::Rake::YardocTask::METHODS -# Did you mean? Method -# uninitialized constant YARD::Rake::YardocTask::OPT_TABLE -# uninitialized constant YARD::Rake::YardocTask::RUBY -# uninitialized constant YARD::Rake::YardocTask::VERSION -# Did you mean? YARD::VERSION -# wrong constant name after -# wrong constant name after= -# wrong constant name before -# wrong constant name before= -# wrong constant name define -# wrong constant name files -# wrong constant name files= -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name options -# wrong constant name options= -# wrong constant name stats_options -# wrong constant name stats_options= -# wrong constant name verifier -# wrong constant name verifier= -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name lookup_by_path -# wrong constant name <static-init> -# wrong constant name [] -# wrong constant name []= -# wrong constant name checksums -# wrong constant name checksums_path -# wrong constant name delete -# wrong constant name destroy -# wrong constant name file -# wrong constant name get -# wrong constant name keys -# wrong constant name load -# wrong constant name load! -# wrong constant name load_all -# wrong constant name load_yardoc -# wrong constant name locale -# wrong constant name lock_for_writing -# wrong constant name locked_for_writing? -# wrong constant name object_types_path -# wrong constant name objects_path -# wrong constant name paths_for_type -# wrong constant name proxy_types -# wrong constant name proxy_types_path -# wrong constant name put -# wrong constant name root -# wrong constant name save -# wrong constant name values -# wrong constant name values_for_type -# wrong constant name <static-init> -# wrong constant name after_serialize -# wrong constant name before_serialize -# wrong constant name exists? -# wrong constant name initialize -# wrong constant name options -# wrong constant name serialize -# wrong constant name serialized_path -# wrong constant name <static-init> -# wrong constant name basepath -# wrong constant name basepath= -# wrong constant name extension -# wrong constant name extension= -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name serialize -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name serialize -# wrong constant name <static-init> -# wrong constant name checksums_path -# wrong constant name complete? -# wrong constant name complete_lock_path -# wrong constant name deserialize -# wrong constant name initialize -# wrong constant name lock_for_writing -# wrong constant name locked_for_writing? -# wrong constant name object_types_path -# wrong constant name objects_path -# wrong constant name processing_path -# wrong constant name proxy_types_path -# wrong constant name serialize -# wrong constant name <static-init> -# wrong constant name add_library -# wrong constant name document_root -# wrong constant name document_root= -# wrong constant name initialize -# wrong constant name libraries -# wrong constant name libraries= -# wrong constant name options -# wrong constant name options= -# wrong constant name router -# wrong constant name router= -# wrong constant name server_options -# wrong constant name server_options= -# wrong constant name start -# wrong constant name <static-init> -# wrong constant name setup -# wrong constant name shutdown -# wrong constant name adapter -# wrong constant name adapter= -# wrong constant name body -# wrong constant name body= -# wrong constant name cache -# wrong constant name caching -# wrong constant name caching= -# wrong constant name call -# wrong constant name command_options -# wrong constant name command_options= -# wrong constant name headers -# wrong constant name headers= -# wrong constant name initialize -# wrong constant name not_found -# wrong constant name path -# wrong constant name path= -# wrong constant name redirect -# wrong constant name render -# wrong constant name request -# wrong constant name request= -# wrong constant name run -# wrong constant name status -# wrong constant name status= -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::DisplayFileCommand::CAN_FORK -# wrong constant name index -# wrong constant name index= -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::DisplayObjectCommand::CAN_FORK -# wrong constant name index -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::FramesCommand::CAN_FORK -# wrong constant name <static-init> -# wrong constant name incremental -# wrong constant name incremental= -# wrong constant name library -# wrong constant name library= -# wrong constant name options -# wrong constant name options= -# wrong constant name serializer -# wrong constant name serializer= -# wrong constant name single_library -# wrong constant name single_library= -# wrong constant name use_fork -# wrong constant name use_fork= -# wrong constant name <static-init> -# wrong constant name options -# wrong constant name options= -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::ListCommand::CAN_FORK -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::RootRequestCommand::DefaultMimeTypes -# uninitialized constant YARD::Server::Commands::RootRequestCommand::ESCAPED -# Did you mean? YARD::Server::Commands::RootRequestCommand::UNESCAPED -# uninitialized constant YARD::Server::Commands::RootRequestCommand::NONASCII -# uninitialized constant YARD::Server::Commands::RootRequestCommand::UNESCAPED -# Did you mean? YARD::Server::Commands::RootRequestCommand::ESCAPED -# uninitialized constant YARD::Server::Commands::RootRequestCommand::UNESCAPED_FORM -# uninitialized constant YARD::Server::Commands::RootRequestCommand::UNESCAPED_PCHAR -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::SearchCommand::CAN_FORK -# wrong constant name query -# wrong constant name query= -# wrong constant name results -# wrong constant name results= -# wrong constant name visible_results -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::StaticFileCommand::CAN_FORK -# uninitialized constant YARD::Server::Commands::StaticFileCommand::DefaultMimeTypes -# uninitialized constant YARD::Server::Commands::StaticFileCommand::ESCAPED -# Did you mean? YARD::Server::Commands::StaticFileCommand::UNESCAPED -# uninitialized constant YARD::Server::Commands::StaticFileCommand::NONASCII -# uninitialized constant YARD::Server::Commands::StaticFileCommand::UNESCAPED -# Did you mean? YARD::Server::Commands::StaticFileCommand::ESCAPED -# uninitialized constant YARD::Server::Commands::StaticFileCommand::UNESCAPED_FORM -# uninitialized constant YARD::Server::Commands::StaticFileCommand::UNESCAPED_PCHAR -# wrong constant name <static-init> -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::DefaultMimeTypes -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::ESCAPED -# Did you mean? YARD::Server::Commands::StaticFileHelpers::UNESCAPED -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::NONASCII -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::UNESCAPED -# Did you mean? YARD::Server::Commands::StaticFileHelpers::ESCAPED -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::UNESCAPED_FORM -# uninitialized constant YARD::Server::Commands::StaticFileHelpers::UNESCAPED_PCHAR -# wrong constant name favicon? -# wrong constant name static_template_file? -# wrong constant name <static-init> -# wrong constant name find_file -# wrong constant name abs_url -# wrong constant name base_path -# wrong constant name mtime -# wrong constant name mtime_url -# wrong constant name router -# wrong constant name url_for -# wrong constant name url_for_file -# wrong constant name url_for_frameset -# wrong constant name url_for_index -# wrong constant name url_for_list -# wrong constant name url_for_main -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name == -# wrong constant name eql? -# wrong constant name equal? -# wrong constant name gemspec -# wrong constant name initialize -# wrong constant name load_yardoc_from_disk -# wrong constant name load_yardoc_from_gem -# wrong constant name name -# wrong constant name name= -# wrong constant name prepare! -# wrong constant name ready? -# wrong constant name source -# wrong constant name source= -# wrong constant name source_path -# wrong constant name source_path= -# wrong constant name source_path_for_disk -# wrong constant name source_path_for_gem -# wrong constant name to_s -# wrong constant name version -# wrong constant name version= -# wrong constant name yardoc_file -# wrong constant name yardoc_file= -# wrong constant name yardoc_file_for_gem -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name adapter -# wrong constant name adapter= -# wrong constant name call -# wrong constant name docs_prefix -# wrong constant name final_options -# wrong constant name initialize -# wrong constant name list_prefix -# wrong constant name parse_library_from_path -# wrong constant name request -# wrong constant name request= -# wrong constant name route -# wrong constant name route_docs -# wrong constant name route_index -# wrong constant name route_list -# wrong constant name route_search -# wrong constant name route_static -# wrong constant name search_prefix -# wrong constant name static_prefix -# wrong constant name <static-init> -# wrong constant name check_static_cache -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name adapter -# wrong constant name adapter= -# wrong constant name do_GET -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name _dump -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name <static-init> -# wrong constant name _load -# wrong constant name parse_tag -# wrong constant name parse_tag_with_name -# wrong constant name parse_tag_with_options -# wrong constant name parse_tag_with_title_and_text -# wrong constant name parse_tag_with_types -# wrong constant name parse_tag_with_types_and_name -# wrong constant name parse_tag_with_types_and_title -# wrong constant name parse_tag_with_types_name_and_default -# wrong constant name <static-init> -# wrong constant name defaults -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name pair -# wrong constant name pair= -# wrong constant name <static-init> -# wrong constant name owner -# wrong constant name owner= -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name owner -# wrong constant name owner= -# wrong constant name tag_name -# wrong constant name tag_name= -# wrong constant name tags -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name <Class:CollectionType> -# wrong constant name <Class:FixedCollectionType> -# wrong constant name <Class:HashCollectionType> -# wrong constant name <Class:Parser> -# wrong constant name <Class:Type> -# wrong constant name initialize -# wrong constant name to_s -# wrong constant name types -# wrong constant name types= -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name initialize -# wrong constant name key_types -# wrong constant name key_types= -# wrong constant name to_s -# wrong constant name value_types -# wrong constant name value_types= -# wrong constant name <static-init> -# uninitialized constant YARD::Tags::TypesExplainer::Parser::BUILTIN_ALL -# uninitialized constant YARD::Tags::TypesExplainer::Parser::BUILTIN_CLASSES -# uninitialized constant YARD::Tags::TypesExplainer::Parser::BUILTIN_EXCEPTIONS -# Did you mean? YARD::Tags::TypesExplainer::Parser::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Tags::TypesExplainer::Parser::BUILTIN_EXCEPTIONS_HASH -# uninitialized constant YARD::Tags::TypesExplainer::Parser::BUILTIN_MODULES -# uninitialized constant YARD::Tags::TypesExplainer::Parser::CONSTANTMATCH -# uninitialized constant YARD::Tags::TypesExplainer::Parser::CONSTANTSTART -# uninitialized constant YARD::Tags::TypesExplainer::Parser::CSEP -# Did you mean? YARD::Tags::TypesExplainer::Parser::CSEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::CSEPQ -# Did you mean? YARD::Tags::TypesExplainer::Parser::ISEPQ -# YARD::Tags::TypesExplainer::Parser::NSEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::ISEP -# Did you mean? YARD::Tags::TypesExplainer::Parser::ISEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::ISEPQ -# Did you mean? YARD::Tags::TypesExplainer::Parser::CSEPQ -# YARD::Tags::TypesExplainer::Parser::NSEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::METHODMATCH -# uninitialized constant YARD::Tags::TypesExplainer::Parser::METHODNAMEMATCH -# Did you mean? YARD::Tags::TypesExplainer::Parser::METHODMATCH -# uninitialized constant YARD::Tags::TypesExplainer::Parser::NAMESPACEMATCH -# Did you mean? YARD::Tags::TypesExplainer::Parser::NamespaceMapper -# uninitialized constant YARD::Tags::TypesExplainer::Parser::NSEP -# Did you mean? YARD::Tags::TypesExplainer::Parser::NSEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::NSEPQ -# Did you mean? YARD::Tags::TypesExplainer::Parser::CSEPQ -# YARD::Tags::TypesExplainer::Parser::ISEPQ -# uninitialized constant YARD::Tags::TypesExplainer::Parser::PROXY_MATCH -# wrong constant name initialize -# wrong constant name parse -# wrong constant name <static-init> -# wrong constant name parse -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name to_s -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name explain -# wrong constant name explain! -# wrong constant name <static-init> -# wrong constant name generate -# wrong constant name register_template_path -# wrong constant name render -# wrong constant name template -# wrong constant name template! -# wrong constant name template_paths -# wrong constant name template_paths= -# wrong constant name with_serializer -# wrong constant name <static-init> -# wrong constant name clear! -# wrong constant name method_for -# wrong constant name format_object_title -# wrong constant name format_object_type -# wrong constant name format_source -# wrong constant name format_types -# wrong constant name globals -# wrong constant name h -# wrong constant name link_file -# wrong constant name link_include_file -# wrong constant name link_include_object -# wrong constant name link_object -# wrong constant name link_url -# wrong constant name linkify -# wrong constant name object -# wrong constant name object= -# wrong constant name owner -# wrong constant name run_verifier -# wrong constant name serializer -# wrong constant name serializer= -# wrong constant name <static-init> -# wrong constant name is_class? -# wrong constant name is_method? -# wrong constant name is_module? -# wrong constant name is_namespace? -# wrong constant name <static-init> -# uninitialized constant YARD::Templates::Helpers::HtmlHelper::MARKUP_EXTENSIONS -# uninitialized constant YARD::Templates::Helpers::HtmlHelper::MARKUP_FILE_SHEBANG -# uninitialized constant YARD::Templates::Helpers::HtmlHelper::MARKUP_PROVIDERS -# wrong constant name anchor_for -# wrong constant name charset -# wrong constant name format_object_name_list -# wrong constant name format_types -# wrong constant name h -# wrong constant name html_markup_asciidoc -# wrong constant name html_markup_html -# wrong constant name html_markup_markdown -# wrong constant name html_markup_none -# wrong constant name html_markup_org -# wrong constant name html_markup_pre -# wrong constant name html_markup_rdoc -# wrong constant name html_markup_ruby -# wrong constant name html_markup_text -# wrong constant name html_markup_textile -# wrong constant name html_markup_textile_strict -# wrong constant name html_syntax_highlight -# wrong constant name html_syntax_highlight_plain -# wrong constant name htmlify -# wrong constant name htmlify_line -# wrong constant name insert_include -# wrong constant name link_file -# wrong constant name link_include_file -# wrong constant name link_include_object -# wrong constant name link_object -# wrong constant name link_url -# wrong constant name mtime -# wrong constant name mtime_url -# wrong constant name resolve_links -# wrong constant name signature -# wrong constant name signature_types -# wrong constant name url_for -# wrong constant name url_for_file -# wrong constant name url_for_frameset -# wrong constant name url_for_index -# wrong constant name url_for_list -# wrong constant name url_for_main -# wrong constant name <static-init> -# wrong constant name urlencode -# wrong constant name html_syntax_highlight_ruby -# wrong constant name <static-init> -# wrong constant name fix_typewriter -# wrong constant name <static-init> -# wrong constant name from_path -# wrong constant name from_path= -# wrong constant name initialize -# wrong constant name to_html -# wrong constant name <static-init> -# wrong constant name load_markup_provider -# wrong constant name markup_class -# wrong constant name markup_file_contents -# wrong constant name markup_for_file -# wrong constant name markup_provider -# wrong constant name <static-init> -# wrong constant name clear_markup_cache -# wrong constant name markup_cache -# wrong constant name markup_cache= -# wrong constant name format_args -# wrong constant name format_block -# wrong constant name format_code -# wrong constant name format_constant -# wrong constant name format_lines -# wrong constant name format_return_types -# wrong constant name <static-init> -# wrong constant name prune_method_listing -# wrong constant name <static-init> -# wrong constant name align_right -# wrong constant name h -# wrong constant name hr -# wrong constant name indent -# wrong constant name signature -# wrong constant name title_align_right -# wrong constant name wrap -# wrong constant name <static-init> -# wrong constant name format_path -# wrong constant name h -# wrong constant name tidy -# wrong constant name uml_visibility -# wrong constant name <static-init> -# wrong constant name << -# wrong constant name == -# uninitialized constant YARD::Templates::Section::Elem -# wrong constant name [] -# wrong constant name any -# wrong constant name eql? -# wrong constant name initialize -# wrong constant name name -# wrong constant name name= -# wrong constant name place -# wrong constant name push -# wrong constant name unshift -# wrong constant name <static-init> -# wrong constant name <Class:ClassMethods> -# uninitialized constant YARD::Templates::Template::T -# wrong constant name class -# wrong constant name class= -# wrong constant name erb -# wrong constant name erb_file_for -# wrong constant name erb_with -# wrong constant name file -# wrong constant name init -# wrong constant name initialize -# wrong constant name inspect -# wrong constant name options -# wrong constant name options= -# wrong constant name run -# wrong constant name section -# wrong constant name section= -# wrong constant name sections -# wrong constant name superb -# wrong constant name yieldall -# uninitialized constant YARD::Templates::Template::ClassMethods::S -# uninitialized constant YARD::Templates::Template::ClassMethods::T -# wrong constant name find_file -# wrong constant name find_nth_file -# wrong constant name full_path -# wrong constant name full_path= -# wrong constant name full_paths -# wrong constant name initialize -# wrong constant name is_a? -# wrong constant name new -# wrong constant name path -# wrong constant name path= -# wrong constant name reset_full_paths -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name <static-init> -# wrong constant name extra_includes -# wrong constant name extra_includes= -# wrong constant name include_extra -# wrong constant name included -# wrong constant name add_expressions -# wrong constant name call -# wrong constant name expressions -# wrong constant name expressions= -# wrong constant name initialize -# wrong constant name method_missing -# wrong constant name o -# wrong constant name object -# wrong constant name run -# wrong constant name <static-init> -# wrong constant name inherited -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name initialize -# wrong constant name <static-init> -# wrong constant name initialize diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi deleted file mode 100644 index f3e809cf..00000000 --- a/sorbet/rbi/hidden-definitions/hidden.rbi +++ /dev/null @@ -1,13856 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi hidden-definitions - -# typed: autogenerated - -class Addrinfo - def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end -end - -class Array - include ::JSON::Ext::Generator::GeneratorMethods::Array - def abbrev(pattern=T.unsafe(nil)); end - - def deconstruct(); end - - def shelljoin(); end - - def to_h(); end -end - -class Array - def self.try_convert(arg); end -end - -BasicObject::BasicObject = BasicObject - -class BigDecimal - def clone(); end - EXCEPTION_NaN = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class BigDecimal - def self.interpret_loosely(arg); end -end - -class Binding - def clone(); end - - def irb(); end -end - -module Bundler::Audit - VERSION = ::T.let(nil, ::T.untyped) -end - -class Bundler::Audit::Database - DEFAULT_PATH = ::T.let(nil, ::T.untyped) - URL = ::T.let(nil, ::T.untyped) - USER_PATH = ::T.let(nil, ::T.untyped) -end - -class Bundler::Dependency - def branch(); end - - def expanded_platforms(); end - - def git(); end -end - -Bundler::Deprecate = Gem::Deprecate - -class Bundler::Env -end - -class Bundler::Env - def self.environment(); end - - def self.report(options=T.unsafe(nil)); end - - def self.write(io); end -end - -class Bundler::Fetcher - def fetch_spec(spec); end - - def fetchers(); end - - def http_proxy(); end - - def initialize(remote); end - - def specs(gem_names, source); end - - def specs_with_retry(gem_names, source); end - - def uri(); end - - def use_api(); end - - def user_agent(); end - FAIL_ERRORS = ::T.let(nil, ::T.untyped) - FETCHERS = ::T.let(nil, ::T.untyped) - HTTP_ERRORS = ::T.let(nil, ::T.untyped) - NET_ERRORS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Fetcher::AuthenticationRequiredError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::BadAuthenticationError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::Base - def api_fetcher?(); end - - def available?(); end - - def display_uri(); end - - def downloader(); end - - def fetch_uri(); end - - def initialize(downloader, remote, display_uri); end - - def remote(); end - - def remote_uri(); end -end - -class Bundler::Fetcher::Base -end - -class Bundler::Fetcher::CertificateFailureError - def initialize(remote_uri); end -end - -class Bundler::Fetcher::CompactIndex - def available?(*args, &blk); end - - def fetch_spec(*args, &blk); end - - def specs(*args, &blk); end - - def specs_for_names(gem_names); end -end - -class Bundler::Fetcher::CompactIndex::ClientFetcher - def call(path, headers); end - - def fetcher(); end - - def fetcher=(_); end - - def ui(); end - - def ui=(_); end -end - -class Bundler::Fetcher::CompactIndex::ClientFetcher - def self.[](*arg); end - - def self.members(); end -end - -class Bundler::Fetcher::CompactIndex - def self.compact_index_request(method_name); end -end - -class Bundler::Fetcher::Dependency - def dependency_api_uri(gem_names=T.unsafe(nil)); end - - def dependency_specs(gem_names); end - - def get_formatted_specs_and_deps(gem_list); end - - def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end - - def unmarshalled_dep_gems(gem_names); end -end - -class Bundler::Fetcher::Dependency -end - -class Bundler::Fetcher::Downloader - def connection(); end - - def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end - - def initialize(connection, redirect_limit); end - - def redirect_limit(); end - - def request(uri, headers); end -end - -class Bundler::Fetcher::Downloader -end - -class Bundler::Fetcher::Index - def fetch_spec(spec); end - - def specs(_gem_names); end -end - -class Bundler::Fetcher::Index -end - -class Bundler::Fetcher::SSLError - def initialize(msg=T.unsafe(nil)); end -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher - def self.api_timeout(); end - - def self.api_timeout=(api_timeout); end - - def self.disable_endpoint(); end - - def self.disable_endpoint=(disable_endpoint); end - - def self.max_retries(); end - - def self.max_retries=(max_retries); end - - def self.redirect_limit(); end - - def self.redirect_limit=(redirect_limit); end -end - -module Bundler::FileUtils - VERSION = ::T.let(nil, ::T.untyped) -end - -class Bundler::FileUtils::Entry_ - def link(dest); end -end - -module Bundler::FileUtils - def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end - - def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end -end - -class Bundler::GemHelper - include ::Rake::DSL - include ::Rake::FileUtilsExt - include ::FileUtils - include ::FileUtils::StreamUtils_ - def allowed_push_host(); end - - def already_tagged?(); end - - def base(); end - - def build_gem(); end - - def built_gem_path(); end - - def clean?(); end - - def committed?(); end - - def gem_command(); end - - def gem_key(); end - - def gem_push?(); end - - def gem_push_host(); end - - def gemspec(); end - - def git_push(remote=T.unsafe(nil)); end - - def guard_clean(); end - - def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end - - def install(); end - - def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end - - def name(); end - - def perform_git_push(options=T.unsafe(nil)); end - - def rubygem_push(path); end - - def sh(cmd, &block); end - - def sh_with_input(cmd); end - - def sh_with_status(cmd, &block); end - - def spec_path(); end - - def tag_version(); end - - def version(); end - - def version_tag(); end -end - -class Bundler::GemHelper - def self.gemspec(&block); end - - def self.install_tasks(opts=T.unsafe(nil)); end - - def self.instance(); end - - def self.instance=(instance); end -end - -class Bundler::GemVersionPromoter - def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end - - def level(); end - - def level=(value); end - - def locked_specs(); end - - def major?(); end - - def minor?(); end - - def prerelease_specified(); end - - def prerelease_specified=(prerelease_specified); end - - def sort_versions(dep, spec_groups); end - - def strict(); end - - def strict=(strict); end - - def unlock_gems(); end - DEBUG = ::T.let(nil, ::T.untyped) -end - -class Bundler::GemVersionPromoter -end - -class Bundler::Graph - def edge_options(); end - - def groups(); end - - def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end - - def node_options(); end - - def output_file(); end - - def output_format(); end - - def relations(); end - - def viz(); end - GRAPH_NAME = ::T.let(nil, ::T.untyped) -end - -class Bundler::Graph::GraphVizClient - def g(); end - - def initialize(graph_instance); end - - def run(); end -end - -class Bundler::Graph::GraphVizClient -end - -class Bundler::Graph -end - -class Bundler::Index - include ::Enumerable -end - -class Bundler::Injector - def initialize(deps, options=T.unsafe(nil)); end - - def inject(gemfile_path, lockfile_path); end - - def remove(gemfile_path, lockfile_path); end - INJECTED_GEMS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Injector - def self.inject(new_deps, options=T.unsafe(nil)); end - - def self.remove(gems, options=T.unsafe(nil)); end -end - -class Bundler::Molinillo::DependencyGraph - include ::Enumerable -end - -class Bundler::Molinillo::DependencyGraph::Log - extend ::Enumerable -end - -class Bundler::Molinillo::DependencyGraph::Vertex - def _recursive_predecessors(vertices=T.unsafe(nil)); end - - def _recursive_successors(vertices=T.unsafe(nil)); end -end - -module Bundler::Plugin::API::Source - def ==(other); end - - def app_cache_dirname(); end - - def app_cache_path(custom_path=T.unsafe(nil)); end - - def bundler_plugin_api_source?(); end - - def cache(spec, custom_path=T.unsafe(nil)); end - - def cached!(); end - - def can_lock?(spec); end - - def dependency_names(); end - - def dependency_names=(dependency_names); end - - def double_check_for(*arg); end - - def eql?(other); end - - def fetch_gemspec_files(); end - - def gem_install_dir(); end - - def hash(); end - - def include?(other); end - - def initialize(opts); end - - def install(spec, opts); end - - def install_path(); end - - def installed?(); end - - def name(); end - - def options(); end - - def options_to_lock(); end - - def post_install(spec, disable_exts=T.unsafe(nil)); end - - def remote!(); end - - def root(); end - - def specs(); end - - def to_lock(); end - - def to_s(); end - - def unlock!(); end - - def unmet_deps(); end - - def uri(); end - - def uri_hash(); end -end - -module Bundler::Plugin::API::Source -end - -module Bundler::Plugin::Events - GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped) - GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped) -end - -class Bundler::Plugin::Index - def installed_plugins(); end - - def plugin_commands(plugin); end -end - -class Bundler::Plugin::Index::CommandConflict - def initialize(plugin, commands); end -end - -class Bundler::Plugin::Index::CommandConflict -end - -class Bundler::Plugin::Index::SourceConflict - def initialize(plugin, sources); end -end - -class Bundler::Plugin::Index::SourceConflict -end - -class Bundler::Plugin::Installer - def install(names, options); end - - def install_definition(definition); end -end - -class Bundler::Plugin::Installer::Git - def generate_bin(spec, disable_extensions=T.unsafe(nil)); end -end - -class Bundler::Plugin::Installer::Git -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer -end - -class Bundler::Plugin::SourceList -end - -class Bundler::Plugin::SourceList -end - -module Bundler::Plugin - def self.list(); end -end - -class Bundler::ProcessLock -end - -class Bundler::ProcessLock - def self.lock(bundle_path=T.unsafe(nil)); end -end - -class Bundler::Retry - def attempt(&block); end - - def attempts(&block); end - - def current_run(); end - - def current_run=(current_run); end - - def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def total_runs(); end - - def total_runs=(total_runs); end -end - -class Bundler::Retry - def self.attempts(); end - - def self.default_attempts(); end - - def self.default_retries(); end -end - -class Bundler::RubyGemsGemInstaller -end - -class Bundler::RubyGemsGemInstaller -end - -class Bundler::RubygemsIntegration - def add_to_load_path(paths); end - - def all_specs(); end - - def backport_ext_builder_monitor(); end - - def correct_for_windows_path(path); end - - def default_stubs(); end - - def find_name(name); end - - def gem_remote_fetcher(); end - - def plain_specs(); end - - def plain_specs=(specs); end - - def stub_rubygems(specs); end - - def use_gemdeps(gemfile); end -end - -class Bundler::Settings::Mirror - def ==(other); end - - def fallback_timeout(); end - - def fallback_timeout=(timeout); end - - def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end - - def uri(); end - - def uri=(uri); end - - def valid?(); end - - def validate!(probe=T.unsafe(nil)); end - DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped) -end - -class Bundler::Settings::Mirror -end - -class Bundler::Settings::Mirrors - def each(&blk); end - - def for(uri); end - - def initialize(prober=T.unsafe(nil)); end - - def parse(key, value); end -end - -class Bundler::Settings::Mirrors -end - -class Bundler::Settings::Validator -end - -class Bundler::Settings::Validator::Rule - def description(); end - - def fail!(key, value, *reasons); end - - def initialize(keys, description, &validate); end - - def k(key); end - - def set(settings, key, value, *reasons); end - - def validate!(key, value, settings); end -end - -class Bundler::Settings::Validator::Rule -end - -class Bundler::Settings::Validator - def self.validate!(key, value, settings); end -end - -class Bundler::Source::Git - def glob(); end -end - -class Bundler::SpecSet - include ::Enumerable -end - -class Bundler::Thor - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end - HELP_MAPPINGS = ::T.let(nil, ::T.untyped) - TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped) - THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module Bundler::Thor::Actions - def _cleanup_options_and_set(options, key); end - - def _shared_configuration(); end - - def action(instance); end - - def add_file(destination, *args, &block); end - - def add_link(destination, *args); end - - def append_file(path, *args, &block); end - - def append_to_file(path, *args, &block); end - - def apply(path, config=T.unsafe(nil)); end - - def behavior(); end - - def behavior=(behavior); end - - def chmod(path, mode, config=T.unsafe(nil)); end - - def comment_lines(path, flag, *args); end - - def copy_file(source, *args, &block); end - - def create_file(destination, *args, &block); end - - def create_link(destination, *args); end - - def destination_root(); end - - def destination_root=(root); end - - def directory(source, *args, &block); end - - def empty_directory(destination, config=T.unsafe(nil)); end - - def find_in_source_paths(file); end - - def get(source, *args, &block); end - - def gsub_file(path, flag, *args, &block); end - - def in_root(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def inject_into_class(path, klass, *args, &block); end - - def inject_into_file(destination, *args, &block); end - - def inject_into_module(path, module_name, *args, &block); end - - def insert_into_file(destination, *args, &block); end - - def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def link_file(source, *args); end - - def prepend_file(path, *args, &block); end - - def prepend_to_file(path, *args, &block); end - - def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end - - def remove_dir(path, config=T.unsafe(nil)); end - - def remove_file(path, config=T.unsafe(nil)); end - - def run(command, config=T.unsafe(nil)); end - - def run_ruby_script(command, config=T.unsafe(nil)); end - - def source_paths(); end - - def template(source, *args, &block); end - - def thor(command, *args); end - - def uncomment_lines(path, flag, *args); end - WARNINGS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Actions::CapturableERB -end - -class Bundler::Thor::Actions::CapturableERB -end - -module Bundler::Thor::Actions::ClassMethods - def add_runtime_options!(); end - - def source_paths(); end - - def source_paths_for_search(); end - - def source_root(path=T.unsafe(nil)); end -end - -module Bundler::Thor::Actions::ClassMethods -end - -class Bundler::Thor::Actions::CreateFile - def data(); end - - def force_on_collision?(); end - - def force_or_skip_or_conflict(force, skip, &block); end - - def identical?(); end - - def initialize(base, destination, data, config=T.unsafe(nil)); end - - def on_conflict_behavior(&block); end - - def render(); end -end - -class Bundler::Thor::Actions::CreateFile -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::Directory - def execute!(); end - - def file_level_lookup(previous_lookup); end - - def files(lookup); end - - def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def source(); end -end - -class Bundler::Thor::Actions::Directory -end - -class Bundler::Thor::Actions::EmptyDirectory - def base(); end - - def config(); end - - def convert_encoded_instructions(filename); end - - def destination(); end - - def destination=(destination); end - - def exists?(); end - - def given_destination(); end - - def initialize(base, destination, config=T.unsafe(nil)); end - - def invoke!(); end - - def invoke_with_conflict_check(&block); end - - def on_conflict_behavior(); end - - def on_file_clash_behavior(); end - - def pretend?(); end - - def relative_destination(); end - - def revoke!(); end - - def say_status(status, color); end -end - -class Bundler::Thor::Actions::EmptyDirectory -end - -class Bundler::Thor::Actions::InjectIntoFile - def behavior(); end - - def flag(); end - - def initialize(base, destination, data, config); end - - def replace!(regexp, string, force); end - - def replacement(); end - - def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end -end - -class Bundler::Thor::Actions::InjectIntoFile -end - -module Bundler::Thor::Actions - def self.included(base); end -end - -class Bundler::Thor::AmbiguousCommandError -end - -class Bundler::Thor::AmbiguousCommandError -end - -Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError - -class Bundler::Thor::Argument - def banner(); end - - def default(); end - - def default_banner(); end - - def description(); end - - def enum(); end - - def human_name(); end - - def initialize(name, options=T.unsafe(nil)); end - - def name(); end - - def required(); end - - def required?(); end - - def show_default?(); end - - def type(); end - - def usage(); end - - def valid_type?(type); end - - def validate!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Argument -end - -class Bundler::Thor::Arguments - def initialize(arguments=T.unsafe(nil)); end - - def parse(args); end - - def remaining(); end - NUMERIC = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Arguments - def self.parse(*args); end - - def self.split(args); end -end - -module Bundler::Thor::Base - def args(); end - - def args=(args); end - - def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def parent_options(); end - - def parent_options=(parent_options); end -end - -module Bundler::Thor::Base::ClassMethods - def all_commands(); end - - def all_tasks(); end - - def allow_incompatible_default_type!(); end - - def argument(name, options=T.unsafe(nil)); end - - def arguments(); end - - def attr_accessor(*arg); end - - def attr_reader(*arg); end - - def attr_writer(*arg); end - - def baseclass(); end - - def basename(); end - - def build_option(name, options, scope); end - - def build_options(options, scope); end - - def check_default_type(); end - - def check_default_type!(); end - - def check_unknown_options(); end - - def check_unknown_options!(); end - - def check_unknown_options?(config); end - - def class_option(name, options=T.unsafe(nil)); end - - def class_options(options=T.unsafe(nil)); end - - def class_options_help(shell, groups=T.unsafe(nil)); end - - def commands(); end - - def create_command(meth); end - - def create_task(meth); end - - def disable_required_check?(command_name); end - - def dispatch(command, given_args, given_opts, config); end - - def exit_on_failure?(); end - - def find_and_refresh_command(name); end - - def find_and_refresh_task(name); end - - def from_superclass(method, default=T.unsafe(nil)); end - - def group(name=T.unsafe(nil)); end - - def handle_argument_error(command, error, args, arity); end - - def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end - - def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end - - def inherited(klass); end - - def initialize_added(); end - - def is_thor_reserved_word?(word, type); end - - def method_added(meth); end - - def namespace(name=T.unsafe(nil)); end - - def no_commands(&block); end - - def no_commands?(); end - - def no_commands_context(); end - - def no_tasks(&block); end - - def print_options(shell, options, group_name=T.unsafe(nil)); end - - def public_command(*names); end - - def public_task(*names); end - - def remove_argument(*names); end - - def remove_class_option(*names); end - - def remove_command(*names); end - - def remove_task(*names); end - - def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end - - def stop_on_unknown_option?(command_name); end - - def strict_args_position(); end - - def strict_args_position!(); end - - def strict_args_position?(config); end - - def tasks(); end -end - -module Bundler::Thor::Base::ClassMethods -end - -module Bundler::Thor::Base - def self.included(base); end - - def self.register_klass_file(klass); end - - def self.shell(); end - - def self.shell=(shell); end - - def self.subclass_files(); end - - def self.subclasses(); end -end - -class Bundler::Thor::Command - def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def handle_argument_error?(instance, error, caller); end - - def handle_no_method_error?(instance, error, caller); end - - def hidden?(); end - - def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end - - def local_method?(instance, name); end - - def not_debugging?(instance); end - - def private_method?(instance); end - - def public_method?(instance); end - - def required_arguments_for(klass, usage); end - - def required_options(); end - - def run(instance, args=T.unsafe(nil)); end - - def sans_backtrace(backtrace, caller); end - FILE_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Command -end - -module Bundler::Thor::CoreExt -end - -class Bundler::Thor::CoreExt::HashWithIndifferentAccess - def [](key); end - - def []=(key, value); end - - def convert_key(key); end - - def delete(key); end - - def fetch(key, *args); end - - def initialize(hash=T.unsafe(nil)); end - - def key?(key); end - - def merge(other); end - - def merge!(other); end - - def method_missing(method, *args); end - - def replace(other_hash); end - - def reverse_merge(other); end - - def reverse_merge!(other_hash); end - - def values_at(*indices); end -end - -class Bundler::Thor::CoreExt::HashWithIndifferentAccess -end - -module Bundler::Thor::CoreExt -end - -Bundler::Thor::Correctable = DidYouMean::Correctable - -class Bundler::Thor::DynamicCommand - def initialize(name, options=T.unsafe(nil)); end -end - -class Bundler::Thor::DynamicCommand -end - -Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand - -class Bundler::Thor::Error -end - -class Bundler::Thor::Error -end - -class Bundler::Thor::Group - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end -end - -class Bundler::Thor::Group - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - def self.banner(); end - - def self.desc(description=T.unsafe(nil)); end - - def self.get_options_from_invocations(group_options, base_options); end - - def self.handle_argument_error(command, error, _args, arity); end - - def self.help(shell); end - - def self.invocation_blocks(); end - - def self.invocations(); end - - def self.invoke(*names, &block); end - - def self.invoke_from_option(*names, &block); end - - def self.printable_commands(*arg); end - - def self.printable_tasks(*arg); end - - def self.remove_invocation(*names); end - - def self.self_command(); end - - def self.self_task(); end -end - -class Bundler::Thor::HiddenCommand -end - -class Bundler::Thor::HiddenCommand -end - -Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand - -module Bundler::Thor::Invocation - def _parse_initialization_options(args, opts, config); end - - def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end - - def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end - - def _shared_configuration(); end - - def current_command_chain(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def invoke(name=T.unsafe(nil), *args); end - - def invoke_all(); end - - def invoke_command(command, *args); end - - def invoke_task(command, *args); end - - def invoke_with_padding(*args); end -end - -module Bundler::Thor::Invocation::ClassMethods - def prepare_for_invocation(key, name); end -end - -module Bundler::Thor::Invocation::ClassMethods -end - -module Bundler::Thor::Invocation - def self.included(base); end -end - -class Bundler::Thor::InvocationError -end - -class Bundler::Thor::InvocationError -end - -module Bundler::Thor::LineEditor -end - -class Bundler::Thor::LineEditor::Basic - def initialize(prompt, options); end - - def options(); end - - def prompt(); end - - def readline(); end -end - -class Bundler::Thor::LineEditor::Basic - def self.available?(); end -end - -class Bundler::Thor::LineEditor::Readline -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion - def initialize(text); end - - def matches(); end -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion -end - -class Bundler::Thor::LineEditor::Readline -end - -module Bundler::Thor::LineEditor - def self.best_available(); end - - def self.readline(prompt, options=T.unsafe(nil)); end -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::NestedContext - def enter(); end - - def entered?(); end -end - -class Bundler::Thor::NestedContext -end - -class Bundler::Thor::NoKwargSpellChecker - def initialize(dictionary); end -end - -class Bundler::Thor::NoKwargSpellChecker -end - -class Bundler::Thor::Option - def aliases(); end - - def array?(); end - - def boolean?(); end - - def dasherize(str); end - - def dasherized?(); end - - def group(); end - - def hash?(); end - - def hide(); end - - def lazy_default(); end - - def numeric?(); end - - def repeatable(); end - - def string?(); end - - def switch_name(); end - - def undasherize(str); end - - def usage(padding=T.unsafe(nil)); end - - def validate_default_type!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Option - def self.parse(key, value); end -end - -class Bundler::Thor::Options - def assign_result!(option, result); end - - def check_unknown!(); end - - def current_is_switch?(); end - - def current_is_switch_formatted?(); end - - def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end - - def normalize_switch(arg); end - - def parse_boolean(switch); end - - def parse_peek(switch, option); end - - def parsing_options?(); end - - def switch?(arg); end - - def switch_option(arg); end - EQ_RE = ::T.let(nil, ::T.untyped) - LONG_RE = ::T.let(nil, ::T.untyped) - OPTS_END = ::T.let(nil, ::T.untyped) - SHORT_NUM = ::T.let(nil, ::T.untyped) - SHORT_RE = ::T.let(nil, ::T.untyped) - SHORT_SQ_RE = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Options - def self.to_switches(options); end -end - -module Bundler::Thor::RakeCompat - include ::Rake::DSL - include ::Rake::FileUtilsExt - include ::FileUtils - include ::FileUtils::StreamUtils_ -end - -module Bundler::Thor::RakeCompat - def self.included(base); end - - def self.rake_classes(); end -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -module Bundler::Thor::Sandbox -end - -module Bundler::Thor::Sandbox -end - -module Bundler::Thor::Shell - def _shared_configuration(); end - - def ask(*args, &block); end - - def error(*args, &block); end - - def file_collision(*args, &block); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def no?(*args, &block); end - - def print_in_columns(*args, &block); end - - def print_table(*args, &block); end - - def print_wrapped(*args, &block); end - - def say(*args, &block); end - - def say_status(*args, &block); end - - def set_color(*args, &block); end - - def shell(); end - - def shell=(shell); end - - def terminal_width(*args, &block); end - - def with_padding(); end - - def yes?(*args, &block); end - SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Basic - def answer_match(possibilities, answer, case_insensitive); end - - def as_unicode(); end - - def ask(statement, *args); end - - def ask_filtered(statement, color, options); end - - def ask_simply(statement, color, options); end - - def base(); end - - def base=(base); end - - def can_display_colors?(); end - - def dynamic_width(); end - - def dynamic_width_stty(); end - - def dynamic_width_tput(); end - - def error(statement); end - - def file_collision(destination); end - - def file_collision_help(); end - - def git_merge_tool(); end - - def indent(count=T.unsafe(nil)); end - - def is?(value); end - - def lookup_color(color); end - - def merge(destination, content); end - - def merge_tool(); end - - def mute(); end - - def mute?(); end - - def no?(statement, color=T.unsafe(nil)); end - - def padding(); end - - def padding=(value); end - - def prepare_message(message, *color); end - - def print_in_columns(array); end - - def print_table(array, options=T.unsafe(nil)); end - - def print_wrapped(message, options=T.unsafe(nil)); end - - def quiet?(); end - - def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_status(status, message, log_status=T.unsafe(nil)); end - - def set_color(string, *arg); end - - def show_diff(destination, content); end - - def stderr(); end - - def stdout(); end - - def terminal_width(); end - - def truncate(string, width); end - - def unix?(); end - - def yes?(statement, color=T.unsafe(nil)); end - DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Basic -end - -class Bundler::Thor::Shell::Color - def are_colors_disabled?(); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Color -end - -class Bundler::Thor::Shell::HTML - def ask(statement, color=T.unsafe(nil)); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::HTML -end - -module Bundler::Thor::Shell -end - -Bundler::Thor::Task = Bundler::Thor::Command - -class Bundler::Thor::UndefinedCommandError - include ::DidYouMean::Correctable - def all_commands(); end - - def command(); end - - def initialize(command, all_commands, namespace); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker -end - -class Bundler::Thor::UndefinedCommandError -end - -Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError - -class Bundler::Thor::UnknownArgumentError - include ::DidYouMean::Correctable - def initialize(switches, unknown); end - - def switches(); end - - def unknown(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker -end - -class Bundler::Thor::UnknownArgumentError -end - -module Bundler::Thor::Util -end - -module Bundler::Thor::Util - def self.camel_case(str); end - - def self.escape_globs(path); end - - def self.escape_html(string); end - - def self.find_by_namespace(namespace); end - - def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.globs_for(path); end - - def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end - - def self.namespace_from_thor_class(constant); end - - def self.namespaces_in_content(contents, file=T.unsafe(nil)); end - - def self.ruby_command(); end - - def self.snake_case(str); end - - def self.thor_classes_in(klass); end - - def self.thor_root(); end - - def self.thor_root_glob(); end - - def self.user_home(); end -end - -class Bundler::Thor - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.check_unknown_options!(options=T.unsafe(nil)); end - - def self.command_help(shell, command_name); end - - def self.default_command(meth=T.unsafe(nil)); end - - def self.default_task(meth=T.unsafe(nil)); end - - def self.deprecation_warning(message); end - - def self.desc(usage, description, options=T.unsafe(nil)); end - - def self.disable_required_check(); end - - def self.disable_required_check!(*command_names); end - - def self.disable_required_check?(command); end - - def self.dispatch(meth, given_args, given_opts, config); end - - def self.dynamic_command_class(); end - - def self.find_command_possibilities(meth); end - - def self.find_task_possibilities(meth); end - - def self.help(shell, subcommand=T.unsafe(nil)); end - - def self.long_desc(long_description, options=T.unsafe(nil)); end - - def self.map(mappings=T.unsafe(nil), **kw); end - - def self.method_option(name, options=T.unsafe(nil)); end - - def self.method_options(options=T.unsafe(nil)); end - - def self.normalize_command_name(meth); end - - def self.normalize_task_name(meth); end - - def self.option(name, options=T.unsafe(nil)); end - - def self.options(options=T.unsafe(nil)); end - - def self.package_name(name, _=T.unsafe(nil)); end - - def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end - - def self.retrieve_command_name(args); end - - def self.retrieve_task_name(args); end - - def self.stop_on_unknown_option(); end - - def self.stop_on_unknown_option!(*command_names); end - - def self.stop_on_unknown_option?(command); end - - def self.subcommand(subcommand, subcommand_class); end - - def self.subcommand_classes(); end - - def self.subcommand_help(cmd); end - - def self.subcommands(); end - - def self.subtask(subcommand, subcommand_class); end - - def self.subtask_help(cmd); end - - def self.subtasks(); end - - def self.task_help(shell, command_name); end -end - -class Bundler::UI::Shell - def add_color(string, *color); end - - def ask(msg); end - - def confirm(msg, newline=T.unsafe(nil)); end - - def debug(msg, newline=T.unsafe(nil)); end - - def debug?(); end - - def error(msg, newline=T.unsafe(nil)); end - - def info(msg, newline=T.unsafe(nil)); end - - def initialize(options=T.unsafe(nil)); end - - def level(name=T.unsafe(nil)); end - - def level=(level); end - - def no?(); end - - def quiet?(); end - - def shell=(shell); end - - def silence(&blk); end - - def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end - - def unprinted_warnings(); end - - def warn(msg, newline=T.unsafe(nil)); end - - def yes?(msg); end - LEVELS = ::T.let(nil, ::T.untyped) -end - -class Bundler::UI::Shell -end - -module Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ABS_URI_REF = ::T.let(nil, ::T.untyped) - DEFAULT_PARSER = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - OPAQUE = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REGISTRY = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - REL_URI_REF = ::T.let(nil, ::T.untyped) - RFC3986_PARSER = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped) - TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped) - UNSAFE = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - VERSION_CODE = ::T.let(nil, ::T.untyped) - WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::Error -end - -class Bundler::URI::Error -end - -module Bundler::URI::Escape - def decode(*arg); end - - def encode(*arg); end - - def escape(*arg); end - - def unescape(*arg); end -end - -module Bundler::URI::Escape -end - -class Bundler::URI::FTP - def set_typecode(v); end - - def typecode(); end - - def typecode=(typecode); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - TYPECODE = ::T.let(nil, ::T.untyped) - TYPECODE_PREFIX = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::FTP - def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end -end - -class Bundler::URI::File - def check_password(user); end - - def check_user(user); end - - def check_userinfo(user); end - - def set_userinfo(v); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::File -end - -class Bundler::URI::Generic - include ::Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - def +(oth); end - - def -(oth); end - - def ==(oth); end - - def absolute(); end - - def absolute?(); end - - def coerce(oth); end - - def component(); end - - def component_ary(); end - - def default_port(); end - - def eql?(oth); end - - def find_proxy(env=T.unsafe(nil)); end - - def fragment(); end - - def fragment=(v); end - - def hierarchical?(); end - - def host(); end - - def host=(v); end - - def hostname(); end - - def hostname=(v); end - - def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end - - def merge(oth); end - - def merge!(oth); end - - def normalize(); end - - def normalize!(); end - - def opaque(); end - - def opaque=(v); end - - def parser(); end - - def password(); end - - def password=(password); end - - def path(); end - - def path=(v); end - - def port(); end - - def port=(v); end - - def query(); end - - def query=(v); end - - def registry(); end - - def registry=(v); end - - def relative?(); end - - def route_from(oth); end - - def route_to(oth); end - - def scheme(); end - - def scheme=(v); end - - def select(*components); end - - def set_host(v); end - - def set_opaque(v); end - - def set_password(v); end - - def set_path(v); end - - def set_port(v); end - - def set_registry(v); end - - def set_scheme(v); end - - def set_user(v); end - - def set_userinfo(user, password=T.unsafe(nil)); end - - def user(); end - - def user=(user); end - - def userinfo(); end - - def userinfo=(userinfo); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - USE_REGISTRY = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::Generic - def self.build(args); end - - def self.build2(args); end - - def self.component(); end - - def self.default_port(); end - - def self.use_proxy?(hostname, addr, port, no_proxy); end - - def self.use_registry(); end -end - -class Bundler::URI::HTTP - def request_uri(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTP -end - -class Bundler::URI::HTTPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTPS -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - SCOPE = ::T.let(nil, ::T.untyped) - SCOPE_BASE = ::T.let(nil, ::T.untyped) - SCOPE_ONE = ::T.let(nil, ::T.untyped) - SCOPE_SUB = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAP -end - -class Bundler::URI::LDAPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAPS -end - -class Bundler::URI::MailTo - def headers(); end - - def headers=(v); end - - def initialize(*arg); end - - def set_headers(v); end - - def set_to(v); end - - def to(); end - - def to=(v); end - - def to_mailtext(); end - - def to_rfc822text(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - EMAIL_REGEXP = ::T.let(nil, ::T.untyped) - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::MailTo -end - -Bundler::URI::Parser = Bundler::URI::RFC2396_Parser - -Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP - -class Bundler::URI::RFC2396_Parser - include ::Bundler::URI::RFC2396_REGEXP - def escape(str, unsafe=T.unsafe(nil)); end - - def extract(str, schemes=T.unsafe(nil)); end - - def initialize(opts=T.unsafe(nil)); end - - def join(*uris); end - - def make_regexp(schemes=T.unsafe(nil)); end - - def parse(uri); end - - def pattern(); end - - def regexp(); end - - def split(uri); end - - def unescape(str, escaped=T.unsafe(nil)); end -end - -class Bundler::URI::RFC2396_Parser -end - -module Bundler::URI::RFC2396_REGEXP -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ALNUM = ::T.let(nil, ::T.untyped) - ALPHA = ::T.let(nil, ::T.untyped) - DOMLABEL = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HEX = ::T.let(nil, ::T.untyped) - HIER_PART = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - HOSTNAME = ::T.let(nil, ::T.untyped) - HOSTPORT = ::T.let(nil, ::T.untyped) - IPV4ADDR = ::T.let(nil, ::T.untyped) - IPV6ADDR = ::T.let(nil, ::T.untyped) - IPV6REF = ::T.let(nil, ::T.untyped) - NET_PATH = ::T.let(nil, ::T.untyped) - OPAQUE_PART = ::T.let(nil, ::T.untyped) - PATH_SEGMENTS = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REG_NAME = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_SEGMENT = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - RESERVED = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TOPLABEL = ::T.let(nil, ::T.untyped) - UNRESERVED = ::T.let(nil, ::T.untyped) - URIC = ::T.let(nil, ::T.untyped) - URIC_NO_SLASH = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - X_ABS_URI = ::T.let(nil, ::T.untyped) - X_REL_URI = ::T.let(nil, ::T.untyped) -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN -end - -module Bundler::URI::RFC2396_REGEXP -end - -class Bundler::URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_URI = ::T.let(nil, ::T.untyped) - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::RFC3986_Parser -end - -module Bundler::URI::Util -end - -module Bundler::URI::Util - def self.make_components_hash(klass, array_hash); end -end - -module Bundler::URI - extend ::Bundler::URI::Escape - def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end - - def self.decode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.encode_www_form(enum, enc=T.unsafe(nil)); end - - def self.encode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.extract(str, schemes=T.unsafe(nil), &block); end - - def self.get_encoding(label); end - - def self.join(*str); end - - def self.parse(uri); end - - def self.regexp(schemes=T.unsafe(nil)); end - - def self.scheme_list(); end - - def self.split(uri); end -end - -module Bundler::VersionRanges -end - -class Bundler::VersionRanges::NEq - def version(); end - - def version=(_); end -end - -class Bundler::VersionRanges::NEq - def self.[](*arg); end - - def self.members(); end -end - -class Bundler::VersionRanges::ReqR - def cover?(v); end - - def empty?(); end - - def left(); end - - def left=(_); end - - def right(); end - - def right=(_); end - - def single?(); end - INFINITY = ::T.let(nil, ::T.untyped) - UNIVERSAL = ::T.let(nil, ::T.untyped) - ZERO = ::T.let(nil, ::T.untyped) -end - -class Bundler::VersionRanges::ReqR::Endpoint - def inclusive(); end - - def inclusive=(_); end - - def version(); end - - def version=(_); end -end - -class Bundler::VersionRanges::ReqR::Endpoint - def self.[](*arg); end - - def self.members(); end -end - -class Bundler::VersionRanges::ReqR - def self.[](*arg); end - - def self.members(); end -end - -module Bundler::VersionRanges - def self.empty?(ranges, neqs); end - - def self.for(requirement); end - - def self.for_many(requirements); end -end - -module Bundler - def self.original_exec(*args); end - - def self.original_system(*args); end - - def self.unbundled_env(); end - - def self.unbundled_exec(*args); end - - def self.unbundled_system(*args); end -end - -module Byebug - PORT = ::T.let(nil, ::T.untyped) -end - -class Byebug::AutoirbSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::AutolistSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::AutoprySetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::AutosaveSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::CallstyleSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::Command - extend ::Byebug::Helpers::StringHelper -end - -class Byebug::Context - extend ::Byebug::Helpers::PathHelper -end - -class Byebug::FullpathSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::HistfileSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::HistsizeSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::ListsizeSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::LocalInterface - EOF_ALIAS = ::T.let(nil, ::T.untyped) -end - -class Byebug::Printers::Base - SEPARATOR = ::T.let(nil, ::T.untyped) -end - -class Byebug::SavefileSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::Setting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -class Byebug::ThreadsTable -end - -class Byebug::ThreadsTable -end - -class Byebug::WidthSetting - DEFAULT = ::T.let(nil, ::T.untyped) -end - -module CGI::HtmlExtension - def a(href=T.unsafe(nil)); end - - def base(href=T.unsafe(nil)); end - - def blockquote(cite=T.unsafe(nil)); end - - def caption(align=T.unsafe(nil)); end - - def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end - - def checkbox_group(name=T.unsafe(nil), *values); end - - def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end - - def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end - - def html(attributes=T.unsafe(nil)); end - - def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end - - def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end - - def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end - - def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def popup_menu(name=T.unsafe(nil), *values); end - - def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end - - def radio_group(name=T.unsafe(nil), *values); end - - def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end - - def scrolling_list(name=T.unsafe(nil), *values); end - - def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end - - def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end - - def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end -end - -module CGI::HtmlExtension -end - -class Class - def json_creatable?(); end -end - -module CodeRay - CODERAY_PATH = ::T.let(nil, ::T.untyped) - TokenKinds = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class CodeRay::Duo - def call(code, options=T.unsafe(nil)); end - - def encode(code, options=T.unsafe(nil)); end - - def encoder(); end - - def format(); end - - def format=(format); end - - def highlight(code, options=T.unsafe(nil)); end - - def initialize(lang=T.unsafe(nil), format=T.unsafe(nil), options=T.unsafe(nil)); end - - def lang(); end - - def lang=(lang); end - - def options(); end - - def options=(options); end - - def scanner(); end -end - -class CodeRay::Duo - def self.[](*arg); end -end - -class CodeRay::Encoders::Encoder - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders - -class CodeRay::Encoders::Terminal - TOKEN_COLORS = ::T.let(nil, ::T.untyped) -end - -module CodeRay::FileType - TypeFromExt = ::T.let(nil, ::T.untyped) - TypeFromName = ::T.let(nil, ::T.untyped) - TypeFromShebang = ::T.let(nil, ::T.untyped) -end - -class CodeRay::FileType::UnknownFileType -end - -class CodeRay::FileType::UnknownFileType -end - -module CodeRay::FileType - def self.[](filename, read_shebang=T.unsafe(nil)); end - - def self.fetch(filename, default=T.unsafe(nil), read_shebang=T.unsafe(nil)); end - - def self.type_from_shebang(filename); end -end - -module CodeRay::PluginHost - PLUGIN_HOSTS = ::T.let(nil, ::T.untyped) - PLUGIN_HOSTS_BY_ID = ::T.let(nil, ::T.untyped) -end - -module CodeRay::Scanners -end - -class CodeRay::Scanners::Scanner - include ::Enumerable - def binary_string(); end - - def column(pos=T.unsafe(nil)); end - - def each(&block); end - - def file_extension(); end - - def initialize(code=T.unsafe(nil), options=T.unsafe(nil)); end - - def lang(); end - - def line(pos=T.unsafe(nil)); end - - def raise_inspect(message, tokens, state=T.unsafe(nil), ambit=T.unsafe(nil), backtrace=T.unsafe(nil)); end - - def raise_inspect_arguments(message, tokens, state, ambit); end - - def reset_instance(); end - - def scan_rest(); end - - def scan_tokens(tokens, options); end - - def scanner_state_info(state); end - - def set_string_from_source(source); end - - def set_tokens_from_options(options); end - - def setup(); end - - def state(); end - - def state=(state); end - - def string=(code); end - - def tokenize(source=T.unsafe(nil), options=T.unsafe(nil)); end - - def tokens(); end - - def tokens_last(tokens, n); end - - def tokens_size(tokens); end - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) - KINDS_NOT_LOC = ::T.let(nil, ::T.untyped) - SCANNER_STATE_INFO = ::T.let(nil, ::T.untyped) - SCAN_ERROR_MESSAGE = ::T.let(nil, ::T.untyped) -end - -CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners - -class CodeRay::Scanners::Scanner::ScanError -end - -class CodeRay::Scanners::Scanner::ScanError -end - -class CodeRay::Scanners::Scanner - extend ::CodeRay::Plugin - def self.encode_with_encoding(code, target_encoding); end - - def self.encoding(name=T.unsafe(nil)); end - - def self.file_extension(extension=T.unsafe(nil)); end - - def self.guess_encoding(s); end - - def self.lang(); end - - def self.normalize(code); end - - def self.to_unix(code); end -end - -module CodeRay::Scanners - extend ::CodeRay::PluginHost -end - -module CodeRay::Styles -end - -class CodeRay::Styles::Style - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles - -class CodeRay::Styles::Style - extend ::CodeRay::Plugin -end - -module CodeRay::Styles - extend ::CodeRay::PluginHost -end - -class CodeRay::Tokens - def begin_group(kind); end - - def begin_line(kind); end - - def count(); end - - def encode(encoder, options=T.unsafe(nil)); end - - def end_group(kind); end - - def end_line(kind); end - - def method_missing(meth, options=T.unsafe(nil)); end - - def scanner(); end - - def scanner=(scanner); end - - def split_into_parts(*sizes); end - - def text_token(*arg); end - - def tokens(*arg); end -end - -class CodeRay::Tokens -end - -class CodeRay::TokensProxy - def block(); end - - def block=(block); end - - def each(*args, &blk); end - - def encode(encoder, options=T.unsafe(nil)); end - - def initialize(input, lang, options=T.unsafe(nil), block=T.unsafe(nil)); end - - def input(); end - - def input=(input); end - - def lang(); end - - def lang=(lang); end - - def method_missing(method, *args, &blk); end - - def options(); end - - def options=(options); end - - def scanner(); end - - def tokens(); end -end - -class CodeRay::TokensProxy -end - -module Codecov - VERSION = ::T.let(nil, ::T.untyped) -end - -class Codecov::SimpleCov::Formatter - RESULT_FILE_NAME = ::T.let(nil, ::T.untyped) -end - -class Codecov::Uploader - APPVEYOR = ::T.let(nil, ::T.untyped) - AZUREPIPELINES = ::T.let(nil, ::T.untyped) - BITBUCKET = ::T.let(nil, ::T.untyped) - BITRISE = ::T.let(nil, ::T.untyped) - BUILDKITE = ::T.let(nil, ::T.untyped) - CIRCLE = ::T.let(nil, ::T.untyped) - CIRRUS = ::T.let(nil, ::T.untyped) - CODEBUILD = ::T.let(nil, ::T.untyped) - CODESHIP = ::T.let(nil, ::T.untyped) - DRONEIO = ::T.let(nil, ::T.untyped) - GITHUB = ::T.let(nil, ::T.untyped) - GITLAB = ::T.let(nil, ::T.untyped) - HEROKU = ::T.let(nil, ::T.untyped) - JENKINS = ::T.let(nil, ::T.untyped) - RECOGNIZED_CIS = ::T.let(nil, ::T.untyped) - SEMAPHORE = ::T.let(nil, ::T.untyped) - SHIPPABLE = ::T.let(nil, ::T.untyped) - SOLANO = ::T.let(nil, ::T.untyped) - TEAMCITY = ::T.let(nil, ::T.untyped) - TRAVIS = ::T.let(nil, ::T.untyped) - WERCKER = ::T.let(nil, ::T.untyped) -end - -class DRb::DRbArray - def _dump(lv); end -end - -class DRb::DRbArray - def self._load(s); end -end - -class DRb::DRbConn - def alive?(); end - - def close(); end - - def initialize(remote_uri); end - - def send_message(ref, msg_id, arg, block); end - - def uri(); end -end - -class DRb::DRbConn - def self.make_pool(); end - - def self.open(remote_uri); end - - def self.stop_pool(); end -end - -class DRb::DRbMessage - def dump(obj, error=T.unsafe(nil)); end - - def initialize(config); end - - def load(soc); end - - def recv_reply(stream); end - - def recv_request(stream); end - - def send_reply(stream, succ, result); end - - def send_request(stream, ref, msg_id, arg, b); end -end - -class DRb::DRbObject - def ==(other); end - - def eql?(other); end - - def initialize(obj, uri=T.unsafe(nil)); end -end - -class DRb::DRbObject - def self.prepare_backtrace(uri, result); end - - def self.with_friend(uri); end -end - -module DRb::DRbProtocol - def self.auto_load(uri); end -end - -class DRb::DRbRemoteError - def initialize(error); end -end - -class DRb::DRbServer - def initialize(uri=T.unsafe(nil), front=T.unsafe(nil), config_or_acl=T.unsafe(nil)); end - - def safe_level(); end -end - -class DRb::DRbServer::InvokeMethod - include ::DRb::DRbServer::InvokeMethod18Mixin - def initialize(drb_server, client); end - - def perform(); end -end - -class DRb::DRbServer::InvokeMethod -end - -module DRb::DRbServer::InvokeMethod18Mixin - def block_yield(x); end - - def perform_with_block(); end -end - -module DRb::DRbServer::InvokeMethod18Mixin -end - -class DRb::DRbServer - def self.default_safe_level(level); end - - def self.make_config(hash=T.unsafe(nil)); end -end - -class DRb::DRbTCPSocket - def accept(); end - - def alive?(); end - - def close(); end - - def initialize(uri, soc, config=T.unsafe(nil)); end - - def peeraddr(); end - - def recv_reply(); end - - def recv_request(); end - - def send_reply(succ, result); end - - def send_request(ref, msg_id, arg, b); end - - def set_sockopt(soc); end - - def shutdown(); end - - def stream(); end - - def uri(); end -end - -class DRb::DRbTCPSocket - def self.getservername(); end - - def self.open(uri, config); end - - def self.open_server(uri, config); end - - def self.open_server_inaddr_any(host, port); end - - def self.parse_uri(uri); end - - def self.uri_option(uri, config); end -end - -class DRb::DRbURIOption - def ==(other); end - - def eql?(other); end - - def initialize(option); end - - def option(); end -end - -class DRb::DRbURIOption -end - -module DRb::DRbUndumped - def _dump(dummy); end -end - -class DRb::DRbUnknown - def _dump(lv); end -end - -class DRb::DRbUnknown - def self._load(s); end -end - -class DRb::DRbUnknownError - def _dump(lv); end - - def initialize(unknown); end -end - -class DRb::DRbUnknownError - def self._load(s); end -end - -class DRb::ThreadObject - include ::MonitorMixin - def _execute(); end - - def alive?(); end - - def initialize(&blk); end - - def kill(); end - - def method_missing(msg, *arg, &blk); end -end - -class DRb::ThreadObject -end - -module DRb - def self.mutex(); end -end - -DRbIdConv = DRb::DRbIdConv - -DRbObject = DRb::DRbObject - -DRbUndumped = DRb::DRbUndumped - -class Date - def infinite?(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class Date::Infinity - def initialize(d=T.unsafe(nil)); end -end - -class Delegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class DidYouMean::ClassNameChecker - def class_name(); end - - def class_names(); end - - def corrections(); end - - def initialize(exception); end - - def scopes(); end -end - -class DidYouMean::CorrectElement - def call(names, element); end -end - -class DidYouMean::CorrectElement -end - -module DidYouMean::Correctable - def corrections(); end - - def original_message(); end - - def spell_checker(); end - - def to_s(); end -end - -module DidYouMean::Jaro - def self.distance(str1, str2); end -end - -module DidYouMean::JaroWinkler - def self.distance(str1, str2); end -end - -class DidYouMean::KeyErrorChecker - def corrections(); end - - def initialize(key_error); end -end - -class DidYouMean::KeyErrorChecker -end - -module DidYouMean::Levenshtein - def self.distance(str1, str2); end - - def self.min3(a, b, c); end -end - -class DidYouMean::MethodNameChecker - def corrections(); end - - def initialize(exception); end - - def method_name(); end - - def method_names(); end - - def names_to_exclude(); end - - def receiver(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -class DidYouMean::NullChecker - def corrections(); end - - def initialize(*arg); end -end - -class DidYouMean::ParseDimensions - def call(); end - - def initialize(dictionary, separator); end -end - -class DidYouMean::ParseDimensions -end - -class DidYouMean::PlainFormatter - def message_for(corrections); end -end - -class DidYouMean::PlainFormatter -end - -class DidYouMean::TreeSpellChecker - def augment(); end - - def correct(input); end - - def dictionary(); end - - def dimensions(); end - - def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end - - def separator(); end -end - -class DidYouMean::TreeSpellChecker -end - -class DidYouMean::VariableNameChecker - def corrections(); end - - def cvar_names(); end - - def initialize(exception); end - - def ivar_names(); end - - def lvar_names(); end - - def method_names(); end - - def name(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module DidYouMean - def self.correct_error(error_class, spell_checker); end - - def self.formatter(); end - - def self.formatter=(formatter); end -end - -class Dir - def children(); end - - def each_child(); end -end - -module Dir::Tmpname - UNUSABLE_CHARS = ::T.let(nil, ::T.untyped) -end - -class Dir - def self.exists?(arg); end -end - -module Docile - VERSION = ::T.let(nil, ::T.untyped) -end - -module Docile::BacktraceFilter - FILTER_PATTERN = ::T.let(nil, ::T.untyped) -end - -class Docile::FallbackContextProxy - NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped) - NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped) - NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped) -end - -class ERB - def def_method(mod, methodname, fname=T.unsafe(nil)); end - - def def_module(methodname=T.unsafe(nil)); end -end - -class ERB::Compiler::Scanner - DEFAULT_ETAGS = ::T.let(nil, ::T.untyped) - DEFAULT_STAGS = ::T.let(nil, ::T.untyped) -end - -class Encoding - def _dump(*arg); end - CESU_8 = ::T.let(nil, ::T.untyped) -end - -class Encoding::Converter - def initialize(*arg); end -end - -class Encoding - def self._load(arg); end -end - -class Enumerator - def +(arg); end - - def each_with_index(); end -end - -class Enumerator::ArithmeticSequence - def begin(); end - - def each(&blk); end - - def end(); end - - def exclude_end?(); end - - def last(*arg); end - - def step(); end -end - -class Enumerator::ArithmeticSequence -end - -class Enumerator::Chain -end - -class Enumerator::Chain -end - -class Enumerator::Generator - def each(*arg, &blk); end - - def initialize(*arg); end -end - -class Enumerator::Producer - def each(&blk); end -end - -class Enumerator::Producer -end - -class Errno::EAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EAUTH -end - -class Errno::EBADARCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADARCH -end - -class Errno::EBADEXEC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADEXEC -end - -class Errno::EBADMACHO - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADMACHO -end - -class Errno::EBADRPC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADRPC -end - -Errno::ECAPMODE = Errno::NOERROR - -Errno::EDEADLOCK = Errno::NOERROR - -class Errno::EDEVERR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EDEVERR -end - -Errno::EDOOFUS = Errno::NOERROR - -class Errno::EFTYPE - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EFTYPE -end - -Errno::EIPSEC = Errno::NOERROR - -class Errno::ELAST - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ELAST -end - -class Errno::ENEEDAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENEEDAUTH -end - -class Errno::ENOATTR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOATTR -end - -class Errno::ENOPOLICY - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOPOLICY -end - -Errno::ENOTCAPABLE = Errno::NOERROR - -class Errno::ENOTSUP - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOTSUP -end - -class Errno::EPROCLIM - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCLIM -end - -class Errno::EPROCUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCUNAVAIL -end - -class Errno::EPROGMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGMISMATCH -end - -class Errno::EPROGUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGUNAVAIL -end - -class Errno::EPWROFF - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPWROFF -end - -Errno::EQFULL = Errno::ELAST - -class Errno::ERPCMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ERPCMISMATCH -end - -class Errno::ESHLIBVERS - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ESHLIBVERS -end - -module Etc - VERSION = ::T.let(nil, ::T.untyped) -end - -class Etc::Group - def gid(); end - - def gid=(_); end - - def mem(); end - - def mem=(_); end - - def name(); end - - def name=(_); end - - def passwd(); end - - def passwd=(_); end -end - -class Etc::Group - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.members(); end -end - -class Etc::Passwd - def change(); end - - def change=(_); end - - def dir=(_); end - - def expire(); end - - def expire=(_); end - - def gecos(); end - - def gecos=(_); end - - def gid=(_); end - - def name=(_); end - - def passwd=(_); end - - def shell=(_); end - - def uclass(); end - - def uclass=(_); end - - def uid=(_); end -end - -class Etc::Passwd - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.members(); end -end - -class ExitCalledError -end - -class ExitCalledError -end - -class FalseClass - include ::JSON::Ext::Generator::GeneratorMethods::FalseClass -end - -class Fiber - def initialize(*arg); end - - def transfer(*arg); end -end - -class Fiber - def self.current(); end -end - -class File - RELATIVE_PARENTDIR = ::T.let(nil, ::T.untyped) - RELATIVE_SAMEDIR = ::T.let(nil, ::T.untyped) -end - -class File - def self.absolute_path?(arg); end - - def self.cleanpath(path, rel_root=T.unsafe(nil)); end - - def self.exists?(arg); end - - def self.open!(file, *args, &block); end - - def self.read_binary(file); end - - def self.relative_path(from, to); end -end - -FileList = Rake::FileList - -module FileUtils - include ::FileUtils::StreamUtils_ - LN_SUPPORTED = ::T.let(nil, ::T.untyped) - RUBY = ::T.let(nil, ::T.untyped) -end - -module FileUtils::DryRun - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::DryRun - extend ::FileUtils::DryRun - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - extend ::FileUtils::NoWrite - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::Verbose - include ::FileUtils - include ::FileUtils::StreamUtils_ -end - -module FileUtils::Verbose - extend ::FileUtils::Verbose - extend ::FileUtils - extend ::FileUtils::StreamUtils_ -end - -module FileUtils - extend ::FileUtils::StreamUtils_ -end - -class Float - include ::JSON::Ext::Generator::GeneratorMethods::Float -end - -module Forwardable - VERSION = ::T.let(nil, ::T.untyped) -end - -module Forwardable - def self._compile_method(src, file, line); end - - def self._delegator_method(obj, accessor, method, ali); end - - def self._valid_method?(method); end - - def self.debug(); end - - def self.debug=(debug); end -end - -module GC - def garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end -end - -module GC - def self.verify_transient_heap_internal_consistency(); end -end - -module Gem - ConfigMap = ::T.let(nil, ::T.untyped) - RbConfigPriorities = ::T.let(nil, ::T.untyped) - RubyGemsVersion = ::T.let(nil, ::T.untyped) - UNTAINT = ::T.let(nil, ::T.untyped) -end - -Gem::Cache = Gem::SourceIndex - -class Gem::Exception - extend ::Gem::Deprecate -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::ExtConfBuilder -end - -Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_ - -class Gem::Ext::ExtConfBuilder - def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil)); end - - def self.get_relative_path(path); end -end - -class Gem::Package - def gem(); end -end - -class Gem::Package::DigestIO - def digests(); end - - def initialize(io, digests); end - - def write(data); end -end - -class Gem::Package::DigestIO - def self.wrap(io, digests); end -end - -class Gem::Package::FileSource - def initialize(path); end - - def path(); end - - def present?(); end - - def start(); end - - def with_read_io(&block); end - - def with_write_io(&block); end -end - -class Gem::Package::FileSource -end - -class Gem::Package::IOSource - def initialize(io); end - - def io(); end - - def path(); end - - def present?(); end - - def start(); end - - def with_read_io(); end - - def with_write_io(); end -end - -class Gem::Package::IOSource -end - -class Gem::Package::Old - def extract_files(destination_dir); end - - def file_list(io); end - - def read_until_dashes(io); end - - def skip_ruby(io); end -end - -class Gem::Package::Old -end - -class Gem::Package::Source -end - -class Gem::Package::Source -end - -class Gem::Package::TarHeader - def ==(other); end - - def checksum(); end - - def devmajor(); end - - def devminor(); end - - def empty?(); end - - def gid(); end - - def gname(); end - - def initialize(vals); end - - def linkname(); end - - def magic(); end - - def mode(); end - - def mtime(); end - - def name(); end - - def prefix(); end - - def size(); end - - def typeflag(); end - - def uid(); end - - def uname(); end - - def update_checksum(); end - - def version(); end - EMPTY_HEADER = ::T.let(nil, ::T.untyped) - FIELDS = ::T.let(nil, ::T.untyped) - PACK_FORMAT = ::T.let(nil, ::T.untyped) - UNPACK_FORMAT = ::T.let(nil, ::T.untyped) -end - -class Gem::Package::TarHeader - def self.from(stream); end - - def self.oct_or_256based(str); end - - def self.strict_oct(str); end -end - -class Gem::Package::TarReader::Entry - def bytes_read(); end - - def check_closed(); end - - def close(); end - - def closed?(); end - - def directory?(); end - - def eof?(); end - - def file?(); end - - def full_name(); end - - def getc(); end - - def header(); end - - def initialize(header, io); end - - def length(); end - - def pos(); end - - def read(len=T.unsafe(nil)); end - - def readpartial(maxlen=T.unsafe(nil), outbuf=T.unsafe(nil)); end - - def rewind(); end - - def size(); end - - def symlink?(); end -end - -class Gem::Package::TarReader::Entry -end - -class Gem::Package::TarReader - def self.new(io); end -end - -class Gem::Package::TarWriter - def self.new(io); end -end - -class Gem::Package - def self.new(gem, security_policy=T.unsafe(nil)); end - - def self.raw_spec(path, security_policy=T.unsafe(nil)); end -end - -class Gem::PathSupport - def home(); end - - def initialize(env); end - - def path(); end - - def spec_cache_dir(); end -end - -class Gem::RemoteFetcher::FetchError - include ::Gem::UriParsing - def initialize(message, uri); end - - def uri(); end - - def uri=(uri); end -end - -class Gem::RemoteFetcher::FetchError -end - -class Gem::RemoteFetcher::UnknownHostError -end - -class Gem::RemoteFetcher::UnknownHostError -end - -class Gem::Request - extend ::Gem::UserInteraction - extend ::Gem::DefaultUserInteraction - extend ::Gem::Text -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::LocalSpecification -end - -class Gem::Resolver::LocalSpecification -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - def add_edge_no_circular(graph, origin, destination, requirement); end - - def add_vertex(graph, name, payload, root); end - - def delete_edge(graph, origin_name, destination_name, requirement); end - - def detach_vertex_named(graph, name); end - - def each(&blk); end - - def pop!(graph); end - - def reverse_each(); end - - def rewind_to(graph, tag); end - - def set_payload(graph, name, payload); end - - def tag(graph, tag); end -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - extend ::Enumerable -end - -class Gem::RuntimeRequirementNotMetError - def suggestion(); end - - def suggestion=(suggestion); end -end - -class Gem::RuntimeRequirementNotMetError -end - -class Gem::Security::Exception -end - -class Gem::Security::Exception -end - -Gem::Security::KEY_ALGORITHM = OpenSSL::PKey::RSA - -class Gem::Security::Signer - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def cert_chain(); end - - def cert_chain=(cert_chain); end - - def digest_algorithm(); end - - def digest_name(); end - - def extract_name(cert); end - - def initialize(key, cert_chain, passphrase=T.unsafe(nil), options=T.unsafe(nil)); end - - def key(); end - - def key=(key); end - - def load_cert_chain(); end - - def options(); end - - def re_sign_key(expiration_length: T.unsafe(nil)); end - - def sign(data); end -end - -class Gem::Security::Signer - def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end -end - -class Gem::Security::TrustDir - def cert_path(certificate); end - - def dir(); end - - def each_certificate(); end - - def initialize(dir, permissions=T.unsafe(nil)); end - - def issuer_of(certificate); end - - def load_certificate(certificate_file); end - - def name_path(name); end - - def trust_cert(certificate); end - - def verify(); end -end - -module Gem::Security - def self.alt_name_or_x509_entry(certificate, x509_entry); end - - def self.create_cert(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end - - def self.create_cert_email(email, key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end - - def self.create_cert_self_signed(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end - - def self.create_key(length=T.unsafe(nil), algorithm=T.unsafe(nil)); end - - def self.email_to_name(email_address); end - - def self.re_sign(expired_certificate, private_key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end - - def self.reset(); end - - def self.sign(certificate, signing_key, signing_cert, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end - - def self.trust_dir(); end - - def self.trusted_certificates(&block); end - - def self.write(pemmable, path, permissions=T.unsafe(nil), passphrase=T.unsafe(nil), cipher=T.unsafe(nil)); end -end - -class Gem::SpecFetcher - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def available_specs(type); end - - def detect(type=T.unsafe(nil)); end - - def initialize(sources=T.unsafe(nil)); end - - def latest_specs(); end - - def prerelease_specs(); end - - def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def sources(); end - - def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def specs(); end - - def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end - - def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end -end - -class Gem::SpecFetcher - def self.fetcher(); end - - def self.fetcher=(fetcher); end -end - -class Gem::Specification - include ::Bundler::MatchPlatform - include ::Bundler::GemHelpers - def removed_method_calls(); end - - def to_ruby(); end - REMOVED_METHODS = ::T.let(nil, ::T.untyped) -end - -class Gem::Specification - extend ::Gem::Deprecate - extend ::Enumerable -end - -class Gem::SpecificationPolicy - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def initialize(specification); end - - def packaging(); end - - def packaging=(packaging); end - - def validate(strict=T.unsafe(nil)); end - - def validate_dependencies(); end - - def validate_metadata(); end - - def validate_permissions(); end - HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped) - LAZY = ::T.let(nil, ::T.untyped) - LAZY_PATTERN = ::T.let(nil, ::T.untyped) - METADATA_LINK_KEYS = ::T.let(nil, ::T.untyped) - SPECIAL_CHARACTERS = ::T.let(nil, ::T.untyped) - VALID_NAME_PATTERN = ::T.let(nil, ::T.untyped) - VALID_URI_PATTERN = ::T.let(nil, ::T.untyped) -end - -class Gem::SpecificationPolicy -end - -class Gem::StreamUI - def _deprecated_debug(statement); end -end - -class Gem::StubSpecification - def build_extensions(); end - - def extensions(); end - - def initialize(filename, base_dir, gems_dir, default_gem); end - - def missing_extensions?(); end - - def valid?(); end -end - -class Gem::StubSpecification::StubLine - def extensions(); end - - def full_name(); end - - def initialize(data, extensions); end - - def name(); end - - def platform(); end - - def require_paths(); end - - def version(); end -end - -class Gem::StubSpecification - def self.default_gemspec_stub(filename, base_dir, gems_dir); end - - def self.gemspec_stub(filename, base_dir, gems_dir); end -end - -class Gem::UninstallError - def spec(); end - - def spec=(spec); end -end - -class Gem::UninstallError -end - -Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError - -Gem::Version::Requirement = Gem::Requirement - -module Gem - def self.activated_gem_paths(); end -end - -class Hash - include ::JSON::Ext::Generator::GeneratorMethods::Hash - def deconstruct_keys(arg); end -end - -class Hash - def self.ruby2_keywords_hash(arg); end - - def self.ruby2_keywords_hash?(arg); end -end - -class IO - def beep(); end - - def check_winsize_changed(); end - - def clear_screen(); end - - def console_mode(); end - - def console_mode=(console_mode); end - - def cooked(); end - - def cooked!(); end - - def cursor(); end - - def cursor=(cursor); end - - def cursor_down(arg); end - - def cursor_left(arg); end - - def cursor_right(arg); end - - def cursor_up(arg); end - - def echo=(echo); end - - def echo?(); end - - def erase_line(arg); end - - def erase_screen(arg); end - - def getch(*arg); end - - def getpass(*arg); end - - def goto(arg, arg1); end - - def goto_column(arg); end - - def iflush(); end - - def ioflush(); end - - def noecho(); end - - def nonblock(*arg); end - - def nonblock=(nonblock); end - - def nonblock?(); end - - def nread(); end - - def oflush(); end - - def pathconf(arg); end - - def pressed?(); end - - def raw(*arg); end - - def raw!(*arg); end - - def ready?(); end - - def scroll_backward(arg); end - - def scroll_forward(arg); end - - def wait(*arg); end - - def wait_readable(*arg); end - - def wait_writable(*arg); end - - def winsize(); end - - def winsize=(winsize); end -end - -class IO::ConsoleMode - def echo=(echo); end - - def raw(*arg); end - - def raw!(*arg); end -end - -class IO::ConsoleMode -end - -IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable - -IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable - -class IO - def self.console(*arg); end - - def self.console_size(); end - - def self.default_console_size(); end -end - -class IPAddr - def ==(other); end - - def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end -end - -module IRB - IRBRC_EXT = ::T.let(nil, ::T.untyped) - MagicFile = ::T.let(nil, ::T.untyped) - STDIN_FILE_NAME = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - REVERSE = ::T.let(nil, ::T.untyped) - UNDERLINE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - def self.clear(); end - - def self.colorable?(); end - - def self.colorize(text, seq); end - - def self.colorize_code(code, complete: T.unsafe(nil)); end - - def self.inspect_colorable?(obj, seen: T.unsafe(nil)); end -end - -class IRB::Context - def __exit__(*arg); end - - def __inspect__(); end - - def __to_s__(); end - - def echo_on_assignment(); end - - def echo_on_assignment=(echo_on_assignment); end - - def echo_on_assignment?(); end - - def evaluate(line, line_no, exception: T.unsafe(nil)); end - - def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def inspect_last_value(); end - - def newline_before_multiline_output(); end - - def newline_before_multiline_output=(newline_before_multiline_output); end - - def newline_before_multiline_output?(); end - - def omit_on_assignment(); end - - def omit_on_assignment=(omit_on_assignment); end - - def omit_on_assignment?(); end - - def use_colorize(); end - - def use_colorize?(); end - - def use_multiline(); end - - def use_multiline?(); end - - def use_reidline(); end - - def use_reidline?(); end - - def use_singleline(); end - - def use_singleline?(); end - IDNAME_IVARS = ::T.let(nil, ::T.untyped) - NOPRINTING_IVARS = ::T.let(nil, ::T.untyped) - NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped) -end - -class IRB::DefaultEncodings - def external(); end - - def external=(_); end - - def internal(); end - - def internal=(_); end -end - -class IRB::DefaultEncodings - def self.[](*arg); end - - def self.members(); end -end - -module IRB::ExtendCommandBundle - def irb(*opts, &b); end - - def irb_change_workspace(*opts, &b); end - - def irb_current_working_workspace(*opts, &b); end - - def irb_fg(*opts, &b); end - - def irb_help(*opts, &b); end - - def irb_info(*opts, &b); end - - def irb_jobs(*opts, &b); end - - def irb_kill(*opts, &b); end - - def irb_pop_workspace(*opts, &b); end - - def irb_push_workspace(*opts, &b); end - - def irb_source(*opts, &b); end - - def irb_workspaces(*opts, &b); end -end - -IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle - -module IRB::ExtendCommandBundle - def self.irb_original_method_name(method_name); end -end - -class IRB::FileInputMethod - def initialize(file); end -end - -module IRB::InputCompletor - BASIC_WORD_BREAK_CHARACTERS = ::T.let(nil, ::T.untyped) - CompletionProc = ::T.let(nil, ::T.untyped) - Operators = ::T.let(nil, ::T.untyped) - PerfectMatchedProc = ::T.let(nil, ::T.untyped) - ReservedWords = ::T.let(nil, ::T.untyped) -end - -module IRB::InputCompletor - def self.ignored_modules(); end - - def self.retrieve_completion_data(input, bind: T.unsafe(nil), doc_namespace: T.unsafe(nil)); end - - def self.select_message(receiver, message, candidates, sep=T.unsafe(nil)); end -end - -class IRB::InputMethod - def initialize(file=T.unsafe(nil)); end - - def winsize(); end -end - -class IRB::Inspector - def initialize(inspect_proc, init_proc=T.unsafe(nil)); end -end - -class IRB::Irb - def assignment_expression?(line); end - - def handle_exception(exc); end - - def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def output_value(omit=T.unsafe(nil)); end - - def prompt(prompt, ltype, indent, line_no); end - ASSIGNMENT_NODE_TYPES = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale - def String(mes); end - - def encoding(); end - - def find(file, paths=T.unsafe(nil)); end - - def format(*opts); end - - def gets(*rs); end - - def initialize(locale=T.unsafe(nil)); end - - def lang(); end - - def load(file, priv=T.unsafe(nil)); end - - def modifier(); end - - def print(*opts); end - - def printf(*opts); end - - def puts(*opts); end - - def readline(*rs); end - - def require(file, priv=T.unsafe(nil)); end - - def territory(); end - LOCALE_DIR = ::T.let(nil, ::T.untyped) - LOCALE_NAME_RE = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale -end - -class IRB::OutputMethod::NotImplementedError - def initialize(val); end -end - -class IRB::ReadlineInputMethod - def initialize(); end -end - -class IRB::ReadlineInputMethod - def self.initialize_readline(); end -end - -class IRB::ReidlineInputMethod - def auto_indent(&block); end - - def check_termination(&block); end - - def dynamic_prompt(&block); end - - def initialize(); end -end - -class IRB::StdioInputMethod - def initialize(); end -end - -class IRB::WorkSpace - def initialize(*main); end - - def local_variable_get(name); end - - def local_variable_set(name, value); end -end - -module IRB - def self.Inspector(inspect, init=T.unsafe(nil)); end - - def self.delete_caller(); end - - def self.init_config(ap_path); end - - def self.init_error(); end - - def self.load_modules(); end - - def self.parse_opts(argv: T.unsafe(nil)); end - - def self.rc_file(ext=T.unsafe(nil)); end - - def self.rc_file_generators(); end - - def self.run_config(); end - - def self.setup(ap_path, argv: T.unsafe(nil)); end -end - -module IgnoreMonkeyPatchMixins - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Integer - include ::JSON::Ext::Generator::GeneratorMethods::Integer - def to_bn(); end -end - -class JSON::Ext::Generator::State - def escape_slash(); end - - def escape_slash=(escape_slash); end - - def escape_slash?(); end -end - -class JSON::Ext::Generator::State - def self.from_state(arg); end -end - -class JSON::Ext::Parser - def initialize(*arg); end -end - -JSON::Parser = JSON::Ext::Parser - -JSON::State = JSON::Ext::Generator::State - -JSON::UnparserError = JSON::GeneratorError - -module JSON - def self.create_fast_state(); end - - def self.create_pretty_state(); end - - def self.load_file(filespec, opts=T.unsafe(nil)); end - - def self.load_file!(filespec, opts=T.unsafe(nil)); end -end - -module Kernel - def pretty_inspect(); end -end - -module Kernel - def self.at_exit(); end -end - -class KeyError - include ::DidYouMean::Correctable -end - -class Logger - def debug!(); end - - def error!(); end - - def fatal!(); end - - def info!(); end - - def warn!(); end - SEV_LABEL = ::T.let(nil, ::T.untyped) -end - -class Logger::Formatter - Format = ::T.let(nil, ::T.untyped) -end - -class Logger::LogDevice - include ::MonitorMixin -end - -module Logger::Period - SiD = ::T.let(nil, ::T.untyped) -end - -class MagicCommentHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -Markdown = RedcarpetCompat - -module MethodSource - VERSION = ::T.let(nil, ::T.untyped) -end - -module MethodSource::CodeHelpers::IncompleteExpression - GENERIC_REGEXPS = ::T.let(nil, ::T.untyped) - RBX_ONLY_REGEXPS = ::T.let(nil, ::T.untyped) -end - -class Monitor - def enter(); end - - def exit(); end - - def mon_check_owner(); end - - def mon_enter(); end - - def mon_exit(); end - - def mon_locked?(); end - - def mon_owned?(); end - - def mon_synchronize(); end - - def mon_try_enter(); end - - def new_cond(); end - - def synchronize(); end - - def try_enter(); end - - def try_mon_enter(); end - - def wait_for_cond(arg, arg1); end -end - -module MonitorMixin - def initialize(*args); end -end - -class MonitorMixin::ConditionVariable - def initialize(monitor); end -end - -class NameError - include ::DidYouMean::Correctable -end - -class Net::BufferedIO - def write_timeout(); end - - def write_timeout=(write_timeout); end -end - -class Net::HTTP - def ipaddr(); end - - def ipaddr=(addr); end - - def max_retries(); end - - def max_retries=(retries); end - - def max_version(); end - - def max_version=(max_version); end - - def min_version(); end - - def min_version=(min_version); end - - def write_timeout(); end - - def write_timeout=(sec); end - ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped) -end - -Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta - -class Net::HTTPAlreadyReported - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPAlreadyReported -end - -Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException - -Net::HTTPClientErrorCode = Net::HTTPClientError - -class Net::HTTPEarlyHints - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPEarlyHints -end - -Net::HTTPFatalErrorCode = Net::HTTPClientError - -Net::HTTPInformationCode = Net::HTTPInformation - -class Net::HTTPLoopDetected - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPLoopDetected -end - -class Net::HTTPMisdirectedRequest - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPMisdirectedRequest -end - -Net::HTTPMovedTemporarily = Net::HTTPFound - -Net::HTTPMultipleChoice = Net::HTTPMultipleChoices - -class Net::HTTPNotExtended - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPNotExtended -end - -class Net::HTTPPayloadTooLarge - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPPayloadTooLarge -end - -class Net::HTTPProcessing - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPProcessing -end - -class Net::HTTPRangeNotSatisfiable - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPRangeNotSatisfiable -end - -Net::HTTPRedirection::EXCEPTION_TYPE = Net::HTTPRetriableError - -Net::HTTPRedirectionCode = Net::HTTPRedirection - -Net::HTTPRequestURITooLarge = Net::HTTPURITooLong - -Net::HTTPResponceReceiver = Net::HTTPResponse - -Net::HTTPRetriableCode = Net::HTTPRedirection - -Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError - -Net::HTTPServerErrorCode = Net::HTTPServerError - -Net::HTTPSession = Net::HTTP - -Net::HTTPSuccessCode = Net::HTTPSuccess - -class Net::HTTPURITooLong - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPURITooLong -end - -Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError - -class Net::HTTPVariantAlsoNegotiates - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPVariantAlsoNegotiates -end - -Net::NetPrivate::HTTPRequest = Net::HTTPRequest - -Net::NetPrivate::Socket = Net::InternetMessageIO - -Net::ProtocRetryError = Net::ProtoRetriableError - -class Net::ReadTimeout - def initialize(io=T.unsafe(nil)); end - - def io(); end -end - -class Net::WriteTimeout - def initialize(io=T.unsafe(nil)); end - - def io(); end -end - -class NilClass - include ::JSON::Ext::Generator::GeneratorMethods::NilClass -end - -class NoMatchingPatternError -end - -class NoMatchingPatternError -end - -class Object - include ::JSON::Ext::Generator::GeneratorMethods::Object - include ::PP::ObjectMixin - def to_yaml(options=T.unsafe(nil)); end - ARGF = ::T.let(nil, ::T.untyped) - ARGV = ::T.let(nil, ::T.untyped) - CROSS_COMPILING = ::T.let(nil, ::T.untyped) - ENV = ::T.let(nil, ::T.untyped) - RUBY18 = ::T.let(nil, ::T.untyped) - RUBY19 = ::T.let(nil, ::T.untyped) - RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped) - RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped) - RUBY_ENGINE = ::T.let(nil, ::T.untyped) - RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped) - RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped) - RUBY_PLATFORM = ::T.let(nil, ::T.untyped) - RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped) - RUBY_REVISION = ::T.let(nil, ::T.untyped) - RUBY_VERSION = ::T.let(nil, ::T.untyped) - STDERR = ::T.let(nil, ::T.untyped) - STDIN = ::T.let(nil, ::T.untyped) - STDOUT = ::T.let(nil, ::T.untyped) - TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) -end - -class Object - def self.yaml_tag(url); end -end - -class OpenSSL::ASN1::ASN1Data - def indefinite_length(); end - - def indefinite_length=(indefinite_length); end -end - -class OpenSSL::BN - def +@(); end - - def -@(); end - - def /(arg); end - - def negative?(); end -end - -module OpenSSL::KDF -end - -class OpenSSL::KDF::KDFError -end - -class OpenSSL::KDF::KDFError -end - -module OpenSSL::KDF - def self.hkdf(*arg); end - - def self.pbkdf2_hmac(*arg); end - - def self.scrypt(*arg); end -end - -class OpenSSL::OCSP::Request - def signed?(); end -end - -OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo - -class OpenSSL::PKey::EC - EXPLICIT_CURVE = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::PKey::EC::Point - def to_octet_string(arg); end -end - -module OpenSSL::SSL - OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped) - OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped) - OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped) - OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped) - OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped) - OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped) - OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped) - SSL2_VERSION = ::T.let(nil, ::T.untyped) - SSL3_VERSION = ::T.let(nil, ::T.untyped) - TLS1_1_VERSION = ::T.let(nil, ::T.untyped) - TLS1_2_VERSION = ::T.let(nil, ::T.untyped) - TLS1_3_VERSION = ::T.let(nil, ::T.untyped) - TLS1_VERSION = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLContext - def alpn_protocols(); end - - def alpn_protocols=(alpn_protocols); end - - def alpn_select_cb(); end - - def alpn_select_cb=(alpn_select_cb); end - - def enable_fallback_scsv(); end - - def max_version=(version); end - - def min_version=(version); end - DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLSocket - def alpn_protocol(); end - - def tmp_key(); end -end - -module OpenSSL::X509 - V_ERR_CA_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_CA_MD_TOO_WEAK = ::T.let(nil, ::T.untyped) - V_ERR_CRL_PATH_VALIDATION_ERROR = ::T.let(nil, ::T.untyped) - V_ERR_DANE_NO_MATCH = ::T.let(nil, ::T.untyped) - V_ERR_DIFFERENT_CRL_SCOPE = ::T.let(nil, ::T.untyped) - V_ERR_EE_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_EMAIL_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_EXCLUDED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_HOSTNAME_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_CALL = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_NON_CA = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_POLICY_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_IP_ADDRESS_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_CRL_SIGN = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = ::T.let(nil, ::T.untyped) - V_ERR_NO_EXPLICIT_POLICY = ::T.let(nil, ::T.untyped) - V_ERR_NO_VALID_SCTS = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_CERT_UNKNOWN = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_FAILED = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_NEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PATH_LOOP = ::T.let(nil, ::T.untyped) - V_ERR_PERMITTED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_PATH_LENGTH_EXCEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_SUBJECT_NAME_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_STORE_LOOKUP = ::T.let(nil, ::T.untyped) - V_ERR_SUBTREE_MINMAX = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_CURVE = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_VERSION = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_LOS_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_UNABLE_TO_GET_CRL_ISSUER = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNNESTED_RESOURCE = ::T.let(nil, ::T.untyped) - V_ERR_UNSPECIFIED = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_TYPE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_EXTENSION_FEATURE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_NAME_SYNTAX = ::T.let(nil, ::T.untyped) - V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped) - V_FLAG_PARTIAL_CHAIN = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS_ONLY = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_192_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped) - V_FLAG_USE_CHECK_TIME = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::X509::Attribute - def ==(other); end -end - -class OpenSSL::X509::CRL - def ==(other); end -end - -class OpenSSL::X509::Extension - def ==(other); end -end - -class OpenSSL::X509::Name - def to_utf8(); end -end - -class OpenSSL::X509::Request - def ==(other); end -end - -class OpenSSL::X509::Revoked - def ==(other); end - - def to_der(); end -end - -module OpenSSL - def self.fips_mode(); end -end - -class OpenStruct - VERSION = ::T.let(nil, ::T.untyped) -end - -class OptionParser - def additional_message(typ, opt); end -end - -class OptionParser::List - def get_candidates(id); end -end - -class OptionParser::ParseError - def additional(); end - - def additional=(additional); end -end - -module Parallel - Stop = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Parallel::UserInterruptHandler - INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped) -end - -ParseError = Racc::ParseError - -module Parser - MESSAGES = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Parser::Context - FLAGS = ::T.let(nil, ::T.untyped) -end - -class Parser::Diagnostic - LEVELS = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer - ESCAPES = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped) - LEX_STATES = ::T.let(nil, ::T.untyped) - PUNCTUATION = ::T.let(nil, ::T.untyped) - PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped) - REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer::Dedenter - TAB_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Parser::Lexer::Literal - DELIMITERS = ::T.let(nil, ::T.untyped) - TYPES = ::T.let(nil, ::T.untyped) -end - -class Parser::MaxNumparamStack - ORDINARY_PARAMS = ::T.let(nil, ::T.untyped) -end - -module Parser::Meta - NODE_TYPES = ::T.let(nil, ::T.untyped) -end - -class Parser::Rewriter - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) -end - -class Parser::Ruby24 - Racc_arg = ::T.let(nil, ::T.untyped) - Racc_debug_parser = ::T.let(nil, ::T.untyped) - Racc_token_to_s_table = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Buffer - ENCODING_RE = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Comment::Associator - MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped) - POSTFIX_TYPES = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::Range - include ::RuboCop::Ext::Range -end - -class Parser::Source::Rewriter - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) -end - -class Parser::Source::TreeRewriter - ACTIONS = ::T.let(nil, ::T.untyped) - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) - POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped) -end - -class Parser::StaticEnvironment - ANONYMOUS_BLOCKARG = ::T.let(nil, ::T.untyped) - FORWARD_ARGS = ::T.let(nil, ::T.untyped) -end - -class Proc - def <<(arg); end - - def >>(arg); end - - def clone(); end -end - -class ProgressBar::Components::Bar - DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped) - DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped) - DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Components::Time - ELAPSED_LABEL = ::T.let(nil, ::T.untyped) - ESTIMATED_LABEL = ::T.let(nil, ::T.untyped) - NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped) - OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped) - OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped) - OOB_TEXT_TO_FORMAT = ::T.let(nil, ::T.untyped) - OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped) - OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped) - TIME_FORMAT = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Components::Title - DEFAULT_TITLE = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Format::Molecule - BAR_MOLECULES = ::T.let(nil, ::T.untyped) - MOLECULES = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Format::String - ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped) - MOLECULE_PATTERN = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Output - DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Outputs::NonTty - DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Outputs::Tty - DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Progress - DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped) - DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped) - DEFAULT_TOTAL = ::T.let(nil, ::T.untyped) -end - -class ProgressBar::Time - TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped) -end - -class Pry - BINDING_METHOD_IMPL = ::T.let(nil, ::T.untyped) - Commands = ::T.let(nil, ::T.untyped) - EMPTY_COMPLETIONS = ::T.let(nil, ::T.untyped) - HAS_SAFE_LEVEL = ::T.let(nil, ::T.untyped) - LOCAL_RC_FILE = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Pry::BasicObject - ENV = ::T.let(nil, ::T.untyped) -end - -Pry::BasicObject::Dir = Dir - -Pry::BasicObject::File = File - -Pry::BasicObject::Kernel = Kernel - -Pry::BasicObject::LoadError = LoadError - -Pry::BasicObject::Pry = Pry - -class Pry::Byebug::Breakpoints::FileBreakpoint - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Pry::Byebug::Breakpoints::MethodBreakpoint - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Pry::Code - extend ::MethodSource::CodeHelpers -end - -class Pry::CodeFile - DEFAULT_EXT = ::T.let(nil, ::T.untyped) - EXTENSIONS = ::T.let(nil, ::T.untyped) - FILES = ::T.let(nil, ::T.untyped) - INITIAL_PWD = ::T.let(nil, ::T.untyped) -end - -class Pry::Command - VOID_VALUE = ::T.let(nil, ::T.untyped) -end - -class Pry::Command::Ls - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -class Pry::Command::Ls::Constants - DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped) -end - -class Pry::Command::Ls::Globals - BUILTIN_GLOBALS = ::T.let(nil, ::T.untyped) - PSEUDO_GLOBALS = ::T.let(nil, ::T.untyped) -end - -class Pry::Command::Wtf - RUBY_FRAME_PATTERN = ::T.let(nil, ::T.untyped) -end - -module Pry::Helpers::DocumentationHelpers - YARD_TAGS = ::T.let(nil, ::T.untyped) -end - -module Pry::Helpers::Text - COLORS = ::T.let(nil, ::T.untyped) -end - -class Pry::Indent - IGNORE_TOKENS = ::T.let(nil, ::T.untyped) - MIDWAY_TOKENS = ::T.let(nil, ::T.untyped) - OPEN_TOKENS = ::T.let(nil, ::T.untyped) - OPTIONAL_DO_TOKENS = ::T.let(nil, ::T.untyped) - SINGLELINE_TOKENS = ::T.let(nil, ::T.untyped) - SPACES = ::T.let(nil, ::T.untyped) - STATEMENT_END_TOKENS = ::T.let(nil, ::T.untyped) -end - -class Pry::InputCompleter - ARRAY_REGEXP = ::T.let(nil, ::T.untyped) - CONSTANT_OR_METHOD_REGEXP = ::T.let(nil, ::T.untyped) - CONSTANT_REGEXP = ::T.let(nil, ::T.untyped) - GLOBALVARIABLE_REGEXP = ::T.let(nil, ::T.untyped) - HEX_REGEXP = ::T.let(nil, ::T.untyped) - NUMERIC_REGEXP = ::T.let(nil, ::T.untyped) - PROC_OR_HASH_REGEXP = ::T.let(nil, ::T.untyped) - REGEX_REGEXP = ::T.let(nil, ::T.untyped) - RESERVED_WORDS = ::T.let(nil, ::T.untyped) - SYMBOL_METHOD_CALL_REGEXP = ::T.let(nil, ::T.untyped) - SYMBOL_REGEXP = ::T.let(nil, ::T.untyped) - TOPLEVEL_LOOKUP_REGEXP = ::T.let(nil, ::T.untyped) - VARIABLE_REGEXP = ::T.let(nil, ::T.untyped) - WORD_ESCAPE_STR = ::T.let(nil, ::T.untyped) -end - -class Pry::Inspector - MAP = ::T.let(nil, ::T.untyped) -end - -class Pry::ObjectPath - SPECIAL_TERMS = ::T.let(nil, ::T.untyped) -end - -class Pry::Output - DEFAULT_SIZE = ::T.let(nil, ::T.untyped) -end - -class Pry::PluginManager - PRY_PLUGIN_PREFIX = ::T.let(nil, ::T.untyped) -end - -class Pry::Slop - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Pry::Slop::Option - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -module Psych - VERSION = ::T.let(nil, ::T.untyped) -end - -module Psych - def self.add_builtin_type(type_tag, &block); end - - def self.add_domain_type(domain, type_tag, &block); end - - def self.add_tag(tag, klass); end - - def self.domain_types(); end - - def self.domain_types=(domain_types); end - - def self.dump_tags(); end - - def self.dump_tags=(dump_tags); end - - def self.libyaml_version(); end - - def self.load_tags(); end - - def self.load_tags=(load_tags); end - - def self.remove_type(type_tag); end -end - -class RDoc::Alias - def initialize(text, old_name, new_name, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::Attr - def initialize(text, name, rw, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::ClassModule - def initialize(name, superclass=T.unsafe(nil)); end -end - -class RDoc::CodeObject - def initialize_visibility(); end -end - -class RDoc::Comment - def initialize(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end - - def line(); end - - def line=(line); end -end - -class RDoc::Constant - def initialize(name, value, comment); end -end - -class RDoc::Context - def add_module_by_normal_module(mod); end - - def initialize_methods_etc(); end -end - -class RDoc::Context::Section - def initialize(parent, title, comment); end -end - -class RDoc::CrossReference - def initialize(context); end -end - -class RDoc::ERBIO - def initialize(str, safe_level=T.unsafe(nil), trim_mode=T.unsafe(nil), eoutvar=T.unsafe(nil)); end -end - -module RDoc::Encoding - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -module RDoc::Encoding - def self.detect_encoding(string); end - - def self.remove_magic_comment(string); end -end - -class RDoc::Generator::Darkfish - def initialize(store, options); end -end - -class RDoc::Generator::JsonIndex - def initialize(parent_generator, options); end -end - -class RDoc::Generator::POT - def initialize(store, options); end -end - -class RDoc::Generator::POT::MessageExtractor - def initialize(store); end -end - -class RDoc::Generator::POT::POEntry - def initialize(msgid, options=T.unsafe(nil)); end -end - -class RDoc::Generator::RI - def initialize(store, options); end -end - -class RDoc::I18n::Locale - def initialize(name); end -end - -class RDoc::I18n::Text - def initialize(raw); end -end - -class RDoc::Markdown - def initialize(extensions=T.unsafe(nil), debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals - def initialize(str, debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::Literals::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markdown::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markup - def add_regexp_handling(pattern, name); end - - def initialize(attribute_manager=T.unsafe(nil)); end -end - -class RDoc::Markup::AttrSpan - def initialize(length); end -end - -class RDoc::Markup::AttributeManager - def add_regexp_handling(pattern, name); end - - def convert_regexp_handlings(str, attrs); end - - def regexp_handlings(); end -end - -class RDoc::Markup::Attributes - def regexp_handling(); end -end - -class RDoc::Markup::Document - def initialize(*parts); end -end - -class RDoc::Markup::Formatter - def add_regexp_handling_RDOCLINK(); end - - def add_regexp_handling_TIDYLINK(); end - - def convert_regexp_handling(target); end - - def initialize(options, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::Include - def initialize(file, include_path); end -end - -class RDoc::Markup::IndentedParagraph - def initialize(indent, *parts); end -end - -class RDoc::Markup::List - def initialize(type=T.unsafe(nil), *items); end -end - -class RDoc::Markup::ListItem - def initialize(label=T.unsafe(nil), *parts); end -end - -class RDoc::Markup::Parser::MyStringScanner - def [](i); end - - def eos?(); end - - def initialize(input); end - - def matched(); end - - def newline!(); end - - def pos(); end - - def scan(re); end - - def unscan(s); end -end - -class RDoc::Markup::Parser::MyStringScanner -end - -class RDoc::Markup::PreProcess - def initialize(input_file_name, include_path); end -end - -class RDoc::Markup::Raw - def initialize(*parts); end -end - -class RDoc::Markup::RegexpHandling - def ==(o); end - - def initialize(type, text); end - - def text(); end - - def text=(text); end - - def type(); end -end - -class RDoc::Markup::RegexpHandling -end - -class RDoc::Markup::ToHtml - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_HYPERLINK(target); end - - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end -end - -class RDoc::Markup::ToHtmlCrossref - def handle_regexp_CROSSREF(target); end - - def initialize(options, from_path, context, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToHtmlSnippet - def handle_regexp_CROSSREF(target); end - - def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToJoinedParagraph - def initialize(); end -end - -class RDoc::Markup::ToLabel - def handle_regexp_CROSSREF(target); end - - def handle_regexp_HARD_BREAK(*node); end - - def handle_regexp_TIDYLINK(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToMarkdown - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end -end - -class RDoc::Markup::ToRdoc - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_SUPPRESSED_CROSSREF(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToTableOfContents - def initialize(); end -end - -class RDoc::Markup::ToTtOnly - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::MethodAttr - def initialize(text, name); end -end - -class RDoc::Mixin - def initialize(name, comment); end -end - -class RDoc::Parser - def initialize(top_level, file_name, content, options, stats); end -end - -class RDoc::Parser::C - def do_classes_and_modules(); end -end - -class RDoc::Parser::RipperStateLex - def get_squashed_tk(); end - - def initialize(code); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - RIPPER_HAS_LEX_STATE = ::T.let(nil, ::T.untyped) -end - -class RDoc::Parser::RipperStateLex::InnerStateLex - def initialize(code); end - - def on_default(event, tok, data); end -end - -class RDoc::Parser::RipperStateLex::InnerStateLex -end - -class RDoc::Parser::RipperStateLex::Token - def char_no(); end - - def char_no=(_); end - - def kind(); end - - def kind=(_); end - - def line_no(); end - - def line_no=(_); end - - def state(); end - - def state=(_); end - - def text(); end - - def text=(_); end -end - -class RDoc::Parser::RipperStateLex::Token - def self.[](*arg); end - - def self.members(); end -end - -class RDoc::Parser::RipperStateLex - def self.end?(token); end - - def self.parse(code); end -end - -class RDoc::Parser::Ruby - def get_included_module_with_optional_parens(); end - - def retrieve_comment_body(tk); end -end - -module RDoc::Parser::RubyTools - def skip_tkspace_without_nl(); end -end - -class RDoc::RD::BlockParser - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RD::Inline - def initialize(rdoc, reference); end -end - -class RDoc::RD::InlineParser - def initialize(block_parser); end - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RI::Driver - def initialize(initial_options=T.unsafe(nil)); end -end - -class RDoc::RI::Driver::NotFoundError - def initialize(klass, suggestions=T.unsafe(nil)); end -end - -RDoc::RI::Store = RDoc::Store - -class RDoc::Require - def initialize(name, comment); end -end - -class RDoc::Servlet - def initialize(server, stores, cache, mount_path=T.unsafe(nil), extra_doc_dirs=T.unsafe(nil)); end -end - -class RDoc::Stats - def initialize(store, num_files, verbosity=T.unsafe(nil)); end -end - -class RDoc::Stats::Quiet - def initialize(num_files); end -end - -class RDoc::Store - def initialize(path=T.unsafe(nil), type=T.unsafe(nil)); end - - def unmatched_constant_alias(); end - - def update_parser_of_file(absolute_name, parser); end -end - -class RDoc::Store::MissingFileError - def initialize(store, file, name); end -end - -class RDoc::Task - def inline_source(); end - - def inline_source=(value); end -end - -module RDoc::Text - def language(); end - - def language=(language); end -end - -class RDoc::TopLevel - def initialize(absolute_name, relative_name=T.unsafe(nil)); end -end - -class REXML::Parsers::BaseParser - EXTERNAL_ID_PUBLIC = ::T.let(nil, ::T.untyped) - EXTERNAL_ID_SYSTEM = ::T.let(nil, ::T.untyped) - PUBLIC_ID = ::T.let(nil, ::T.untyped) - QNAME = ::T.let(nil, ::T.untyped) - QNAME_STR = ::T.let(nil, ::T.untyped) -end - -class REXML::Parsers::XPathParser - LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped) - PREFIX_WILDCARD = ::T.let(nil, ::T.untyped) -end - -class REXML::XPathParser - DEBUG = ::T.let(nil, ::T.untyped) -end - -module RSpec - MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped) -end - -class RSpec::CallerFilter - ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped) - IGNORE_REGEX = ::T.let(nil, ::T.untyped) - LIB_REGEX = ::T.let(nil, ::T.untyped) - RSPEC_LIBS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Bisect::Channel - MARSHAL_DUMP_ENCODING = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Configuration - DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped) - FAILED_STATUS = ::T.let(nil, ::T.untyped) - MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped) - PASSED_STATUS = ::T.let(nil, ::T.untyped) - PENDING_STATUS = ::T.let(nil, ::T.untyped) - RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) - UNKNOWN_STATUS = ::T.let(nil, ::T.untyped) - VALID_STATUSES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::ConfigurationOptions - OPTIONS_ORDER = ::T.let(nil, ::T.untyped) - UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped) - UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped) -end - -RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - -class RSpec::Core::ExampleGroup - INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped) -end - -RSpec::Core::ExclusionRules = RSpec::Core::FilterRules - -class RSpec::Core::FilterRules - PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped) - PROJECT_DIR = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::ConsoleCodes - VT100_CODES = ::T.let(nil, ::T.untyped) - VT100_CODE_VALUES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::DeprecationFormatter - DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped) - RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped) - TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter - TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::ExceptionPresenter - PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::Helpers - DEFAULT_PRECISION = ::T.let(nil, ::T.untyped) - SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Formatters::HtmlPrinter - GLOBAL_SCRIPTS = ::T.let(nil, ::T.untyped) - GLOBAL_STYLES = ::T.let(nil, ::T.untyped) - HTML_HEADER = ::T.let(nil, ::T.untyped) - REPORT_HEADER = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation - RESET_CODE = ::T.let(nil, ::T.untyped) -end - -RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation - -class RSpec::Core::Hooks::HookCollections - EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped) - HOOK_TYPES = ::T.let(nil, ::T.untyped) - SCOPES = ::T.let(nil, ::T.untyped) - SCOPE_ALIASES = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Metadata - RESERVED_KEYS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Ordering::Random - MAX_32_BIT = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Pending - NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped) - NO_REASON_GIVEN = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Profiler - NOTIFICATIONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Core::Reporter - RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::ShellEscape - SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped) -end - -module RSpec::Core::Version - STRING = ::T.let(nil, ::T.untyped) -end - -class RSpec::Expectations::Configuration - FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped) -end - -RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter - -module RSpec::Expectations::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Matchers - BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped) - DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped) - HAS_REGEX = ::T.let(nil, ::T.untyped) -end - -RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages - -class RSpec::Matchers::BuiltIn::BaseMatcher - UNDEFINED = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::BuiltIn::BePredicate - REGEX = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::BuiltIn::Equal - LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::BuiltIn::Has - REGEX = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::BuiltIn::RaiseError - UndefinedValue = ::T.let(nil, ::T.untyped) -end - -RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject - -RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith - -module RSpec::Matchers::DSL::Macros - RAISE_NOTIFIER = ::T.let(nil, ::T.untyped) -end - -class RSpec::Matchers::ExpectedsForMultipleDiffs - DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped) - DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped) -end - -module RSpec::Mocks - DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped) - IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::AnyInstance::PositiveExpectationChain - ExpectationInvocationOrder = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::AnyInstance::Recorder - include ::T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions -end - -class RSpec::Mocks::AnyInstance::StubChain - EmptyInvocationOrder = ::T.let(nil, ::T.untyped) - InvocationOrder = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentListMatcher - MATCH_ALL = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher - INSTANCE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher - INSTANCE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentMatchers::BooleanMatcher - INSTANCE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher - INSTANCE = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::Matchers::HaveReceived - ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped) - CONSTRAINTS = ::T.let(nil, ::T.untyped) - COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::MethodDouble - include ::T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions -end - -class RSpec::Mocks::ObjectReference - MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped) -end - -class RSpec::Mocks::Proxy - DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped) -end - -module RSpec::Mocks::Version - STRING = ::T.let(nil, ::T.untyped) -end - -RSpec::SharedContext = RSpec::Core::SharedContext - -module RSpec::Support - DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped) - DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) - KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped) -end - -module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue - AVOID_RESCUING = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::Differ - def color?(); end - - def diff(actual, expected); end - - def diff_as_object(actual, expected); end - - def diff_as_string(actual, expected); end - - def initialize(opts=T.unsafe(nil)); end -end - -class RSpec::Support::Differ -end - -class RSpec::Support::EncodedString - REPLACE = ::T.let(nil, ::T.untyped) - US_ASCII = ::T.let(nil, ::T.untyped) - UTF_8 = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::MethodSignature - INFINITY = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::Mutex - NEW_MUTEX_METHOD = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter - ELLIPSIS = ::T.let(nil, ::T.untyped) - INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::DateTimeInspector - FORMAT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::TimeInspector - FORMAT = ::T.let(nil, ::T.untyped) -end - -class RSpec::Support::ObjectFormatter::UninspectableObjectInspector - OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped) -end - -RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier - -module RSpec::Support::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RSpec::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module Racc - Copyright = ::T.let(nil, ::T.untyped) - Racc_No_Extentions = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Racc::CparseParams -end - -class Racc::CparseParams -end - -class Racc::Parser - Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped) - Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped) - Racc_Runtime_Revision = ::T.let(nil, ::T.untyped) - Racc_Runtime_Type = ::T.let(nil, ::T.untyped) - Racc_Runtime_Version = ::T.let(nil, ::T.untyped) - Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped) -end - -module Rake - EARLY = ::T.let(nil, ::T.untyped) - EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped) - LATE = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Rake::Application - DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped) -end - -module Rake::Backtrace - SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped) - SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped) - SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped) - SYS_KEYS = ::T.let(nil, ::T.untyped) - SYS_PATHS = ::T.let(nil, ::T.untyped) -end - -module Rake::DSL - include ::FileUtils::StreamUtils_ -end - -class Rake::FileList - ARRAY_METHODS = ::T.let(nil, ::T.untyped) - DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped) - DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped) - DELEGATING_METHODS = ::T.let(nil, ::T.untyped) - GLOB_PATTERN = ::T.let(nil, ::T.untyped) - MUST_DEFINE = ::T.let(nil, ::T.untyped) - MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped) - SPECIAL_RETURN = ::T.let(nil, ::T.untyped) -end - -module Rake::FileUtilsExt - include ::FileUtils::StreamUtils_ - DEFAULT = ::T.let(nil, ::T.untyped) -end - -module Rake::FileUtilsExt - extend ::FileUtils::StreamUtils_ -end - -class Rake::InvocationChain - EMPTY = ::T.let(nil, ::T.untyped) -end - -class Rake::LinkedList - EMPTY = ::T.let(nil, ::T.untyped) -end - -class Rake::Promise - NOT_SET = ::T.let(nil, ::T.untyped) -end - -Rake::RDocTask = RDoc::Task - -class Rake::Scope - EMPTY = ::T.let(nil, ::T.untyped) -end - -class Rake::TaskLib - include ::FileUtils::StreamUtils_ -end - -module Rake::Version - BUILD = ::T.let(nil, ::T.untyped) - MAJOR = ::T.let(nil, ::T.untyped) - MINOR = ::T.let(nil, ::T.untyped) - NUMBERS = ::T.let(nil, ::T.untyped) - OTHER = ::T.let(nil, ::T.untyped) -end - -module Rake - extend ::FileUtils::StreamUtils_ -end - -RakeFileUtils = Rake::FileUtilsExt - -class Random - def self.bytes(arg); end -end - -class Range - def %(arg); end - - def entries(); end - - def to_a(); end -end - -module RbConfig - def self.expand(val, config=T.unsafe(nil)); end - - def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end - - def self.ruby(); end -end - -module Readline - def self.completion_quote_character(); end -end - -module Redcarpet - VERSION = ::T.let(nil, ::T.untyped) -end - -class RedcarpetCompat - EXTENSION_MAP = ::T.let(nil, ::T.untyped) - RENDERER_OPTIONS = ::T.let(nil, ::T.untyped) -end - -class Regexp - TOKEN_KEYS = ::T.let(nil, ::T.untyped) -end - -Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative - -Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine - -Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString - -Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine - -Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString - -Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine - -Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence - -Regexp::Expression::MatchLength = Regexp::MatchLength - -class Regexp::Expression::Quantifier - MODES = ::T.let(nil, ::T.untyped) -end - -class Regexp::Lexer - CLOSING_TOKENS = ::T.let(nil, ::T.untyped) - CONDITION_TOKENS = ::T.let(nil, ::T.untyped) - OPENING_TOKENS = ::T.let(nil, ::T.untyped) -end - -class Regexp::Parser - ENC_FLAGS = ::T.let(nil, ::T.untyped) - MOD_FLAGS = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty - -module Regexp::Syntax - VERSION_CONST_REGEXP = ::T.let(nil, ::T.untyped) - VERSION_FORMAT = ::T.let(nil, ::T.untyped) - VERSION_REGEXP = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token - All = ::T.let(nil, ::T.untyped) - Map = ::T.let(nil, ::T.untyped) - Types = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Anchor - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - MatchStart = ::T.let(nil, ::T.untyped) - String = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Assertion - All = ::T.let(nil, ::T.untyped) - Lookahead = ::T.let(nil, ::T.untyped) - Lookbehind = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Backreference - All = ::T.let(nil, ::T.untyped) - Name = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) - NumberRef = ::T.let(nil, ::T.untyped) - Plain = ::T.let(nil, ::T.untyped) - RecursionLevel = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - V1_8_6 = ::T.let(nil, ::T.untyped) - V1_9_1 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::CharacterSet - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::CharacterType - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Clustered = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Hex = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Conditional - All = ::T.let(nil, ::T.untyped) - Condition = ::T.let(nil, ::T.untyped) - Delimiters = ::T.let(nil, ::T.untyped) - Separator = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Escape - ASCII = ::T.let(nil, ::T.untyped) - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Control = ::T.let(nil, ::T.untyped) - Hex = ::T.let(nil, ::T.untyped) - Meta = ::T.let(nil, ::T.untyped) - Octal = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - Unicode = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::FreeSpace - All = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Group - All = ::T.let(nil, ::T.untyped) - Atomic = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Comment = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Named = ::T.let(nil, ::T.untyped) - Passive = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - V1_8_6 = ::T.let(nil, ::T.untyped) - V2_4_1 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Keep - All = ::T.let(nil, ::T.untyped) - Mark = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Literal - All = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Meta - All = ::T.let(nil, ::T.untyped) - Basic = ::T.let(nil, ::T.untyped) - Extended = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::PosixClass - All = ::T.let(nil, ::T.untyped) - Extensions = ::T.let(nil, ::T.untyped) - NonType = ::T.let(nil, ::T.untyped) - Standard = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::Quantifier - All = ::T.let(nil, ::T.untyped) - Greedy = ::T.let(nil, ::T.untyped) - Interval = ::T.let(nil, ::T.untyped) - IntervalAll = ::T.let(nil, ::T.untyped) - IntervalPossessive = ::T.let(nil, ::T.untyped) - IntervalReluctant = ::T.let(nil, ::T.untyped) - Possessive = ::T.let(nil, ::T.untyped) - Reluctant = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - V1_8_6 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::SubexpressionCall - All = ::T.let(nil, ::T.untyped) - Name = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::UnicodeProperty - Age = ::T.let(nil, ::T.untyped) - Age_V1_9_3 = ::T.let(nil, ::T.untyped) - Age_V2_0_0 = ::T.let(nil, ::T.untyped) - Age_V2_2_0 = ::T.let(nil, ::T.untyped) - Age_V2_3_0 = ::T.let(nil, ::T.untyped) - Age_V2_4_0 = ::T.let(nil, ::T.untyped) - Age_V2_5_0 = ::T.let(nil, ::T.untyped) - Age_V2_6_0 = ::T.let(nil, ::T.untyped) - Age_V2_6_2 = ::T.let(nil, ::T.untyped) - Age_V2_6_3 = ::T.let(nil, ::T.untyped) - Age_V3_1_0 = ::T.let(nil, ::T.untyped) - Age_V3_2_0 = ::T.let(nil, ::T.untyped) - All = ::T.let(nil, ::T.untyped) - CharType_V1_9_0 = ::T.let(nil, ::T.untyped) - CharType_V2_5_0 = ::T.let(nil, ::T.untyped) - Derived = ::T.let(nil, ::T.untyped) - Derived_V1_9_0 = ::T.let(nil, ::T.untyped) - Derived_V2_0_0 = ::T.let(nil, ::T.untyped) - Derived_V2_4_0 = ::T.let(nil, ::T.untyped) - Derived_V2_5_0 = ::T.let(nil, ::T.untyped) - Emoji = ::T.let(nil, ::T.untyped) - Emoji_V2_5_0 = ::T.let(nil, ::T.untyped) - NonType = ::T.let(nil, ::T.untyped) - POSIX = ::T.let(nil, ::T.untyped) - Script = ::T.let(nil, ::T.untyped) - Script_V1_9_0 = ::T.let(nil, ::T.untyped) - Script_V1_9_3 = ::T.let(nil, ::T.untyped) - Script_V2_0_0 = ::T.let(nil, ::T.untyped) - Script_V2_2_0 = ::T.let(nil, ::T.untyped) - Script_V2_3_0 = ::T.let(nil, ::T.untyped) - Script_V2_4_0 = ::T.let(nil, ::T.untyped) - Script_V2_5_0 = ::T.let(nil, ::T.untyped) - Script_V2_6_0 = ::T.let(nil, ::T.untyped) - Script_V2_6_2 = ::T.let(nil, ::T.untyped) - Script_V3_1_0 = ::T.let(nil, ::T.untyped) - Script_V3_2_0 = ::T.let(nil, ::T.untyped) - Type = ::T.let(nil, ::T.untyped) - UnicodeBlock = ::T.let(nil, ::T.untyped) - UnicodeBlock_V1_9_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_0_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_2_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_3_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_4_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_5_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_6_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V2_6_2 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V3_1_0 = ::T.let(nil, ::T.untyped) - UnicodeBlock_V3_2_0 = ::T.let(nil, ::T.untyped) - V1_9_0 = ::T.let(nil, ::T.untyped) - V1_9_3 = ::T.let(nil, ::T.untyped) - V2_0_0 = ::T.let(nil, ::T.untyped) - V2_2_0 = ::T.let(nil, ::T.untyped) - V2_3_0 = ::T.let(nil, ::T.untyped) - V2_4_0 = ::T.let(nil, ::T.untyped) - V2_5_0 = ::T.let(nil, ::T.untyped) - V2_6_0 = ::T.let(nil, ::T.untyped) - V2_6_2 = ::T.let(nil, ::T.untyped) - V2_6_3 = ::T.let(nil, ::T.untyped) - V3_1_0 = ::T.let(nil, ::T.untyped) - V3_2_0 = ::T.let(nil, ::T.untyped) -end - -module Regexp::Syntax::Token::UnicodeProperty::Category - All = ::T.let(nil, ::T.untyped) - Codepoint = ::T.let(nil, ::T.untyped) - Letter = ::T.let(nil, ::T.untyped) - Mark = ::T.let(nil, ::T.untyped) - Number = ::T.let(nil, ::T.untyped) - Punctuation = ::T.let(nil, ::T.untyped) - Separator = ::T.let(nil, ::T.untyped) - Symbol = ::T.let(nil, ::T.untyped) -end - -module Reline - FILENAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - HISTORY = ::T.let(nil, ::T.untyped) - USERNAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Reline::ANSI - RAW_KEYSTROKE_CONFIG = ::T.let(nil, ::T.untyped) -end - -class Reline::Config - def vi_cmd_mode_icon(); end - - def vi_cmd_mode_icon=(vi_cmd_mode_icon); end - - def vi_ins_mode_icon(); end - - def vi_ins_mode_icon=(vi_ins_mode_icon); end - KEYSEQ_PATTERN = ::T.let(nil, ::T.untyped) - VARIABLE_NAMES = ::T.let(nil, ::T.untyped) - VARIABLE_NAME_SYMBOLS = ::T.let(nil, ::T.untyped) -end - -class Reline::Core - def ambiguous_width=(ambiguous_width); end - ATTR_READER_NAMES = ::T.let(nil, ::T.untyped) -end - -class Reline::GeneralIO - RAW_KEYSTROKE_CONFIG = ::T.let(nil, ::T.untyped) -end - -Reline::IOGate = Reline::ANSI - -Reline::Key = Struct::Key - -class Reline::KeyActor::Base - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::Emacs - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViCommand - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViInsert - MAPPING = ::T.let(nil, ::T.untyped) -end - -module Reline::KillRing::State - CONTINUED = ::T.let(nil, ::T.untyped) - FRESH = ::T.let(nil, ::T.untyped) - PROCESSED = ::T.let(nil, ::T.untyped) - YANK = ::T.let(nil, ::T.untyped) -end - -class Reline::LineEditor - VI_MOTIONS = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::CompletionJourneyData = Struct::CompletionJourneyData - -module Reline::LineEditor::CompletionState - COMPLETION = ::T.let(nil, ::T.untyped) - JOURNEY = ::T.let(nil, ::T.untyped) - MENU = ::T.let(nil, ::T.untyped) - MENU_WITH_PERFECT_MATCH = ::T.let(nil, ::T.untyped) - NORMAL = ::T.let(nil, ::T.untyped) - PERFECT_MATCH = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::MenuInfo = Struct::MenuInfo - -class Reline::Unicode - CSI_REGEXP = ::T.let(nil, ::T.untyped) - EscapedChars = ::T.let(nil, ::T.untyped) - EscapedPairs = ::T.let(nil, ::T.untyped) - NON_PRINTING_END = ::T.let(nil, ::T.untyped) - NON_PRINTING_START = ::T.let(nil, ::T.untyped) - OSC_REGEXP = ::T.let(nil, ::T.untyped) - WIDTH_SCANNER = ::T.let(nil, ::T.untyped) -end - -class Reline::Unicode::EastAsianWidth - TYPE_A = ::T.let(nil, ::T.untyped) - TYPE_F = ::T.let(nil, ::T.untyped) - TYPE_H = ::T.let(nil, ::T.untyped) - TYPE_N = ::T.let(nil, ::T.untyped) - TYPE_NA = ::T.let(nil, ::T.untyped) - TYPE_W = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS - def extract_resources(msg, name, typeclass); end - RequestID = ::T.let(nil, ::T.untyped) - RequestIDMutex = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Config - def initialize(config_info=T.unsafe(nil)); end -end - -class Resolv::DNS::Label::Str - def initialize(string); end -end - -class Resolv::DNS::Message - def initialize(id=T.unsafe(nil)); end -end - -class Resolv::DNS::Message::MessageDecoder - def initialize(data); end -end - -class Resolv::DNS::Requester::ConnectedUDP - def initialize(host, port=T.unsafe(nil)); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::Sender - def initialize(msg, data, sock); end -end - -class Resolv::DNS::Requester::TCP - def initialize(host, port=T.unsafe(nil)); end -end - -class Resolv::DNS::Requester::UnconnectedUDP - def initialize(*nameserver_port); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::UnconnectedUDP::Sender - def initialize(msg, data, sock, host, port); end -end - -class Resolv::DNS::Resource - ClassValue = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Resource::LOC - def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end -end - -class Resolv::DNS - def self.allocate_request_id(host, port); end - - def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end - - def self.free_request_id(host, port, id); end - - def self.random(arg); end -end - -class Ripper - def column(); end - - def debug_output(); end - - def debug_output=(debug_output); end - - def encoding(); end - - def end_seen?(); end - - def error?(); end - - def filename(); end - - def initialize(*arg); end - - def lineno(); end - - def parse(); end - - def state(); end - - def token(); end - - def yydebug(); end - - def yydebug=(yydebug); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped) - SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Ripper::Filter - def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end -end - -class Ripper::Lexer - def errors(); end - - def lex(); end - - def scan(); end - - def tokenize(); end -end - -class Ripper::Lexer::Elem - def event(); end - - def event=(_); end - - def initialize(pos, event, tok, state, message=T.unsafe(nil)); end - - def message(); end - - def message=(_); end - - def pos(); end - - def pos=(_); end - - def state(); end - - def state=(_); end - - def tok(); end - - def tok=(_); end -end - -class Ripper::Lexer::Elem - def self.[](*arg); end - - def self.members(); end -end - -class Ripper::Lexer::State - def &(i); end - - def ==(i); end - - def allbits?(i); end - - def anybits?(i); end - - def initialize(i); end - - def nobits?(i); end - - def to_i(); end - - def to_int(); end - - def to_int=(_); end - - def to_s=(_); end - - def |(i); end -end - -class Ripper::Lexer::State - def self.[](*arg); end - - def self.members(); end -end - -class Ripper::Lexer -end - -class Ripper::SexpBuilder - def on_BEGIN(*args); end - - def on_CHAR(tok); end - - def on_END(*args); end - - def on___end__(tok); end - - def on_alias(*args); end - - def on_alias_error(*args); end - - def on_aref(*args); end - - def on_aref_field(*args); end - - def on_arg_ambiguous(*args); end - - def on_arg_paren(*args); end - - def on_args_add(*args); end - - def on_args_add_block(*args); end - - def on_args_add_star(*args); end - - def on_args_forward(*args); end - - def on_args_new(*args); end - - def on_array(*args); end - - def on_aryptn(*args); end - - def on_assign(*args); end - - def on_assign_error(*args); end - - def on_assoc_new(*args); end - - def on_assoc_splat(*args); end - - def on_assoclist_from_args(*args); end - - def on_backref(tok); end - - def on_backtick(tok); end - - def on_bare_assoc_hash(*args); end - - def on_begin(*args); end - - def on_binary(*args); end - - def on_block_var(*args); end - - def on_blockarg(*args); end - - def on_bodystmt(*args); end - - def on_brace_block(*args); end - - def on_break(*args); end - - def on_call(*args); end - - def on_case(*args); end - - def on_class(*args); end - - def on_class_name_error(*args); end - - def on_comma(tok); end - - def on_command(*args); end - - def on_command_call(*args); end - - def on_comment(tok); end - - def on_const(tok); end - - def on_const_path_field(*args); end - - def on_const_path_ref(*args); end - - def on_const_ref(*args); end - - def on_cvar(tok); end - - def on_def(*args); end - - def on_defined(*args); end - - def on_defs(*args); end - - def on_do_block(*args); end - - def on_dot2(*args); end - - def on_dot3(*args); end - - def on_dyna_symbol(*args); end - - def on_else(*args); end - - def on_elsif(*args); end - - def on_embdoc(tok); end - - def on_embdoc_beg(tok); end - - def on_embdoc_end(tok); end - - def on_embexpr_beg(tok); end - - def on_embexpr_end(tok); end - - def on_embvar(tok); end - - def on_ensure(*args); end - - def on_excessed_comma(*args); end - - def on_fcall(*args); end - - def on_field(*args); end - - def on_float(tok); end - - def on_for(*args); end - - def on_gvar(tok); end - - def on_hash(*args); end - - def on_heredoc_beg(tok); end - - def on_heredoc_end(tok); end - - def on_hshptn(*args); end - - def on_ident(tok); end - - def on_if(*args); end - - def on_if_mod(*args); end - - def on_ifop(*args); end - - def on_ignored_nl(tok); end - - def on_ignored_sp(tok); end - - def on_imaginary(tok); end - - def on_in(*args); end - - def on_int(tok); end - - def on_ivar(tok); end - - def on_kw(tok); end - - def on_kwrest_param(*args); end - - def on_label(tok); end - - def on_label_end(tok); end - - def on_lambda(*args); end - - def on_lbrace(tok); end - - def on_lbracket(tok); end - - def on_lparen(tok); end - - def on_magic_comment(*args); end - - def on_massign(*args); end - - def on_method_add_arg(*args); end - - def on_method_add_block(*args); end - - def on_mlhs_add(*args); end - - def on_mlhs_add_post(*args); end - - def on_mlhs_add_star(*args); end - - def on_mlhs_new(*args); end - - def on_mlhs_paren(*args); end - - def on_module(*args); end - - def on_mrhs_add(*args); end - - def on_mrhs_add_star(*args); end - - def on_mrhs_new(*args); end - - def on_mrhs_new_from_args(*args); end - - def on_next(*args); end - - def on_nl(tok); end - - def on_nokw_param(*args); end - - def on_op(tok); end - - def on_opassign(*args); end - - def on_operator_ambiguous(*args); end - - def on_param_error(*args); end - - def on_params(*args); end - - def on_paren(*args); end - - def on_parse_error(*args); end - - def on_period(tok); end - - def on_program(*args); end - - def on_qsymbols_add(*args); end - - def on_qsymbols_beg(tok); end - - def on_qsymbols_new(*args); end - - def on_qwords_add(*args); end - - def on_qwords_beg(tok); end - - def on_qwords_new(*args); end - - def on_rational(tok); end - - def on_rbrace(tok); end - - def on_rbracket(tok); end - - def on_redo(*args); end - - def on_regexp_add(*args); end - - def on_regexp_beg(tok); end - - def on_regexp_end(tok); end - - def on_regexp_literal(*args); end - - def on_regexp_new(*args); end - - def on_rescue(*args); end - - def on_rescue_mod(*args); end - - def on_rest_param(*args); end - - def on_retry(*args); end - - def on_return(*args); end - - def on_return0(*args); end - - def on_rparen(tok); end - - def on_sclass(*args); end - - def on_semicolon(tok); end - - def on_sp(tok); end - - def on_stmts_add(*args); end - - def on_stmts_new(*args); end - - def on_string_add(*args); end - - def on_string_concat(*args); end - - def on_string_content(*args); end - - def on_string_dvar(*args); end - - def on_string_embexpr(*args); end - - def on_string_literal(*args); end - - def on_super(*args); end - - def on_symbeg(tok); end - - def on_symbol(*args); end - - def on_symbol_literal(*args); end - - def on_symbols_add(*args); end - - def on_symbols_beg(tok); end - - def on_symbols_new(*args); end - - def on_tlambda(tok); end - - def on_tlambeg(tok); end - - def on_top_const_field(*args); end - - def on_top_const_ref(*args); end - - def on_tstring_beg(tok); end - - def on_tstring_content(tok); end - - def on_tstring_end(tok); end - - def on_unary(*args); end - - def on_undef(*args); end - - def on_unless(*args); end - - def on_unless_mod(*args); end - - def on_until(*args); end - - def on_until_mod(*args); end - - def on_var_alias(*args); end - - def on_var_field(*args); end - - def on_var_ref(*args); end - - def on_vcall(*args); end - - def on_void_stmt(*args); end - - def on_when(*args); end - - def on_while(*args); end - - def on_while_mod(*args); end - - def on_word_add(*args); end - - def on_word_new(*args); end - - def on_words_add(*args); end - - def on_words_beg(tok); end - - def on_words_new(*args); end - - def on_words_sep(tok); end - - def on_xstring_add(*args); end - - def on_xstring_literal(*args); end - - def on_xstring_new(*args); end - - def on_yield(*args); end - - def on_yield0(*args); end - - def on_zsuper(*args); end -end - -class Ripper::TokenPattern - def initialize(pattern); end - - def match(str); end - - def match_list(tokens); end - MAP = ::T.let(nil, ::T.untyped) -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::MatchData - def initialize(tokens, match); end - - def string(n=T.unsafe(nil)); end -end - -class Ripper::TokenPattern::MatchData -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern - def self.compile(*arg); end -end - -class Ripper - def self.dedent_string(arg, arg1); end - - def self.lex_state_name(arg); end - - def self.token_match(src, pattern); end -end - -class RuboCop::AST::Builder - NODE_MAP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::Node - ARGUMENT_TYPES = ::T.let(nil, ::T.untyped) - ASSIGNMENTS = ::T.let(nil, ::T.untyped) - BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped) - BASIC_LITERALS = ::T.let(nil, ::T.untyped) - COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped) - COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped) - CONDITIONALS = ::T.let(nil, ::T.untyped) - EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped) - FALSEY_LITERALS = ::T.let(nil, ::T.untyped) - IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - LITERALS = ::T.let(nil, ::T.untyped) - LOOP_TYPES = ::T.let(nil, ::T.untyped) - MUTABLE_LITERALS = ::T.let(nil, ::T.untyped) - OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped) - POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped) - REFERENCES = ::T.let(nil, ::T.untyped) - SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped) - SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped) - TRUTHY_LITERALS = ::T.let(nil, ::T.untyped) - VARIABLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern - VAR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Compiler::Debug - def comments(*args, &block); end - - def node_ids(); end - - def tokens(*args, &block); end -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer - def compiler(); end - - def initialize(pattern, compiler: T.unsafe(nil)); end - - def node_pattern(); end - - def pattern(); end - - def test(ruby, trace: T.unsafe(nil)); end - COLOR_SCHEME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result - def color_map(color_scheme=T.unsafe(nil)); end - - def colorize(color_scheme=T.unsafe(nil)); end - - def colorizer(); end - - def colorizer=(_); end - - def match_map(); end - - def matched?(node); end - - def returned(); end - - def returned=(_); end - - def ruby_ast(); end - - def ruby_ast=(_); end - - def trace(); end - - def trace=(_); end -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer::Result - def self.[](*arg); end - - def self.members(); end -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Colorizer -end - -module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler - def do_compile(); end -end - -module RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler -end - -class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler - include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler -end - -class RuboCop::AST::NodePattern::Compiler::Debug::NodePatternSubcompiler -end - -class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler - include ::RuboCop::AST::NodePattern::Compiler::Debug::InstrumentationSubcompiler -end - -class RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Trace - def enter(node_id); end - - def matched?(node_id); end - - def success(node_id); end -end - -class RuboCop::AST::NodePattern::Compiler::Debug::Trace -end - -class RuboCop::AST::NodePattern::Compiler::Debug -end - -class RuboCop::AST::NodePattern::Compiler::SequenceSubcompiler - DELTA = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::LexerRex - CALL = ::T.let(nil, ::T.untyped) - CONST_NAME = ::T.let(nil, ::T.untyped) - IDENTIFIER = ::T.let(nil, ::T.untyped) - NODE_TYPE = ::T.let(nil, ::T.untyped) - REGEXP = ::T.let(nil, ::T.untyped) - REGEXP_BODY = ::T.let(nil, ::T.untyped) - SYMBOL_NAME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Node - MAP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Node::Repetition - ARITIES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Parser - Racc_arg = ::T.let(nil, ::T.untyped) - Racc_debug_parser = ::T.let(nil, ::T.untyped) - Racc_token_to_s_table = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern::Parser::WithMeta - def comments(); end - - def tokens(); end -end - -class RuboCop::AST::NodePattern::Parser::WithMeta::Builder - def emit_atom(type, token); end - - def emit_call(type, selector_t, args=T.unsafe(nil)); end - - def emit_list(type, begin_t, children, end_t); end - - def emit_unary_op(type, operator_t=T.unsafe(nil), *children); end -end - -class RuboCop::AST::NodePattern::Parser::WithMeta::Builder -end - -class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer - def initialize(str_or_buffer); end - - def pos(); end -end - -class RuboCop::AST::NodePattern::Parser::WithMeta::Lexer -end - -class RuboCop::AST::NodePattern::Parser::WithMeta -end - -module RuboCop::AST::NodePattern::Sets - MAX = ::T.let(nil, ::T.untyped) - REGISTRY = ::T.let(nil, ::T.untyped) - SET_0_1 = ::T.let(nil, ::T.untyped) - SET_0_1_2 = ::T.let(nil, ::T.untyped) - SET_10_10 = ::T.let(nil, ::T.untyped) - SET_1_1 = ::T.let(nil, ::T.untyped) - SET_1_2 = ::T.let(nil, ::T.untyped) - SET_ABSTRACT_OVERRIDE_OVERRIDABLE_ETC = ::T.let(nil, ::T.untyped) - SET_ADD_DEPENDENCY_ADD_RUNTIME_DEPENDENCY_ADD_DEVELOPMENT_DEPENDENCY = ::T.let(nil, ::T.untyped) - SET_ALL_CONTEXT = ::T.let(nil, ::T.untyped) - SET_AND_RETURN_AND_RAISE_AND_THROW_ETC = ::T.let(nil, ::T.untyped) - SET_ANY_ALL_NORETURN_ETC = ::T.let(nil, ::T.untyped) - SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR = ::T.let(nil, ::T.untyped) - SET_ATTR_READER_ATTR_WRITER_ATTR_ACCESSOR_ATTR = ::T.let(nil, ::T.untyped) - SET_BACKGROUND_SCENARIO_XSCENARIO_ETC = ::T.let(nil, ::T.untyped) - SET_BEFORE_AFTER = ::T.let(nil, ::T.untyped) - SET_BE_EQ_EQL_EQUAL = ::T.let(nil, ::T.untyped) - SET_BE_TRUTHY_BE_FALSEY_BE_FALSY_ETC = ::T.let(nil, ::T.untyped) - SET_BRANCH_REF_TAG = ::T.let(nil, ::T.untyped) - SET_CALLER_CALLER_LOCATIONS = ::T.let(nil, ::T.untyped) - SET_CALL_RUN = ::T.let(nil, ::T.untyped) - SET_CAPTURE2_CAPTURE2E_CAPTURE3_ETC = ::T.let(nil, ::T.untyped) - SET_CIPHER_DIGEST = ::T.let(nil, ::T.untyped) - SET_CLASS_EVAL_INSTANCE_EVAL = ::T.let(nil, ::T.untyped) - SET_CLASS_EVAL_MODULE_EVAL = ::T.let(nil, ::T.untyped) - SET_CLASS_MODULE = ::T.let(nil, ::T.untyped) - SET_CLASS_MODULE_STRUCT = ::T.let(nil, ::T.untyped) - SET_CONSTANTIZE_CONSTANTS_CONST_GET = ::T.let(nil, ::T.untyped) - SET_CONTEXT_SHARED_CONTEXT = ::T.let(nil, ::T.untyped) - SET_COUNT_LENGTH_SIZE = ::T.let(nil, ::T.untyped) - SET_DEFINE_METHOD = ::T.let(nil, ::T.untyped) - SET_DEFINE_METHOD_DEFINE_SINGLETON_METHOD = ::T.let(nil, ::T.untyped) - SET_DOUBLE_SPY = ::T.let(nil, ::T.untyped) - SET_DOWNCASE_UPCASE = ::T.let(nil, ::T.untyped) - SET_EACH_EXAMPLE = ::T.let(nil, ::T.untyped) - SET_EACH_WITH_INDEX_WITH_INDEX = ::T.let(nil, ::T.untyped) - SET_EACH_WITH_OBJECT_WITH_OBJECT = ::T.let(nil, ::T.untyped) - SET_ENUMERATOR_RATIONAL_COMPLEX_THREAD = ::T.let(nil, ::T.untyped) - SET_EQL_EQ_BE = ::T.let(nil, ::T.untyped) - SET_ESCAPE_ENCODE_UNESCAPE_DECODE = ::T.let(nil, ::T.untyped) - SET_EXACTLY_AT_LEAST_AT_MOST = ::T.let(nil, ::T.untyped) - SET_EXIST_EXISTS = ::T.let(nil, ::T.untyped) - SET_EXPECT_ALLOW = ::T.let(nil, ::T.untyped) - SET_FACTORYGIRL_FACTORYBOT = ::T.let(nil, ::T.untyped) - SET_FILETEST_FILE_DIR_SHELL = ::T.let(nil, ::T.untyped) - SET_FIRST_LAST__ETC = ::T.let(nil, ::T.untyped) - SET_FIXNUM_BIGNUM = ::T.let(nil, ::T.untyped) - SET_FLATTEN_FLATTEN = ::T.let(nil, ::T.untyped) - SET_FORMAT_SPRINTF_PRINTF = ::T.let(nil, ::T.untyped) - SET_GSUB_GSUB = ::T.let(nil, ::T.untyped) - SET_GSUB_GSUB_SUB_SUB = ::T.let(nil, ::T.untyped) - SET_INCLUDE_EXTEND_PREPEND = ::T.let(nil, ::T.untyped) - SET_INCLUDE_MEMBER = ::T.let(nil, ::T.untyped) - SET_INSTANCE_EVAL_CLASS_EVAL_MODULE_EVAL = ::T.let(nil, ::T.untyped) - SET_INSTANCE_EXEC_CLASS_EXEC_MODULE_EXEC = ::T.let(nil, ::T.untyped) - SET_IO_FILE = ::T.let(nil, ::T.untyped) - SET_IS_EXPECTED_SHOULD_SHOULD_NOT = ::T.let(nil, ::T.untyped) - SET_KEYS_VALUES = ::T.let(nil, ::T.untyped) - SET_KEY_HAS_KEY_FETCH_ETC = ::T.let(nil, ::T.untyped) - SET_LAST_FIRST = ::T.let(nil, ::T.untyped) - SET_LENGTH_SIZE = ::T.let(nil, ::T.untyped) - SET_LOAD_RESTORE = ::T.let(nil, ::T.untyped) - SET_MAP_COLLECT = ::T.let(nil, ::T.untyped) - SET_MATCH_MATCH = ::T.let(nil, ::T.untyped) - SET_MATCH__MATCH = ::T.let(nil, ::T.untyped) - SET_NEW_ = ::T.let(nil, ::T.untyped) - SET_NEW_COMPILE = ::T.let(nil, ::T.untyped) - SET_NEW_OPEN = ::T.let(nil, ::T.untyped) - SET_NIL_ = ::T.let(nil, ::T.untyped) - SET_PIPELINE_PIPELINE_R_PIPELINE_RW_ETC = ::T.let(nil, ::T.untyped) - SET_PRIVATE_PROTECTED = ::T.let(nil, ::T.untyped) - SET_PRIVATE_PROTECTED_PUBLIC = ::T.let(nil, ::T.untyped) - SET_PROC_LAMBDA = ::T.let(nil, ::T.untyped) - SET_PROP_CONST = ::T.let(nil, ::T.untyped) - SET_PUBLIC_CONSTANT_PRIVATE_CONSTANT = ::T.let(nil, ::T.untyped) - SET_PUBLIC_PROTECTED_PRIVATE_MODULE_FUNCTION = ::T.let(nil, ::T.untyped) - SET_RAISE_ERROR_RAISE_EXCEPTION = ::T.let(nil, ::T.untyped) - SET_RAISE_FAIL = ::T.let(nil, ::T.untyped) - SET_RAISE_FAIL_THROW_ETC = ::T.let(nil, ::T.untyped) - SET_RECEIVE_HAVE_RECEIVED = ::T.let(nil, ::T.untyped) - SET_RECEIVE_MESSAGE_CHAIN_STUB_CHAIN = ::T.let(nil, ::T.untyped) - SET_RECEIVE_RECEIVE_MESSAGES_RECEIVE_MESSAGE_CHAIN_HAVE_RECEIVED = ::T.let(nil, ::T.untyped) - SET_RECEIVE_RECEIVE_MESSAGE_CHAIN = ::T.let(nil, ::T.untyped) - SET_REDUCE_INJECT = ::T.let(nil, ::T.untyped) - SET_REJECT_REJECT = ::T.let(nil, ::T.untyped) - SET_REQUIRE_REQUIRE_RELATIVE = ::T.let(nil, ::T.untyped) - SET_SELECT_FILTER_FIND_ALL_REJECT = ::T.let(nil, ::T.untyped) - SET_SELECT_SELECT = ::T.let(nil, ::T.untyped) - SET_SEND_PUBLIC_SEND___SEND__ = ::T.let(nil, ::T.untyped) - SET_SHOULD_SHOULD_NOT = ::T.let(nil, ::T.untyped) - SET_SKIP_PENDING = ::T.let(nil, ::T.untyped) - SET_SORT_BY_SORT = ::T.let(nil, ::T.untyped) - SET_SORT_MIN_MAX = ::T.let(nil, ::T.untyped) - SET_SPAWN_SYSTEM = ::T.let(nil, ::T.untyped) - SET_SPRINTF_FORMAT = ::T.let(nil, ::T.untyped) - SET_START_WITH_END_WITH = ::T.let(nil, ::T.untyped) - SET_START_WITH_STARTS_WITH_END_WITH_ENDS_WITH = ::T.let(nil, ::T.untyped) - SET_STRUCT_CLASS = ::T.let(nil, ::T.untyped) - SET_SUCC_PRED_NEXT = ::T.let(nil, ::T.untyped) - SET_TASK_NAMESPACE = ::T.let(nil, ::T.untyped) - SET_TEMPFILE_STRINGIO = ::T.let(nil, ::T.untyped) - SET_TO_ENUM_ENUM_FOR = ::T.let(nil, ::T.untyped) - SET_TO_H_TO_HASH = ::T.let(nil, ::T.untyped) - SET_TO_I_TO_F_TO_C_TO_R = ::T.let(nil, ::T.untyped) - SET_TRUE_FALSE = ::T.let(nil, ::T.untyped) - SET_TYPE_TEMPLATE_TYPE_MEMBER = ::T.let(nil, ::T.untyped) - SET_ZERO_POSITIVE_NEGATIVE = ::T.let(nil, ::T.untyped) - SET__ = ::T.let(nil, ::T.untyped) - SET__AT_SLICE = ::T.let(nil, ::T.untyped) - SET__EQL_ = ::T.let(nil, ::T.untyped) - SET__EQUAL_EQL = ::T.let(nil, ::T.untyped) - SET__FETCH = ::T.let(nil, ::T.untyped) - SET__GLOB = ::T.let(nil, ::T.untyped) - SET___ = ::T.let(nil, ::T.untyped) - SET___2 = ::T.let(nil, ::T.untyped) - SET___3 = ::T.let(nil, ::T.untyped) - SET___4 = ::T.let(nil, ::T.untyped) - SET___5 = ::T.let(nil, ::T.untyped) - SET___6 = ::T.let(nil, ::T.untyped) - SET___7 = ::T.let(nil, ::T.untyped) - SET___8 = ::T.let(nil, ::T.untyped) - SET___EQL_ETC = ::T.let(nil, ::T.untyped) - SET___EQL_INCLUDE = ::T.let(nil, ::T.untyped) - SET___METHOD_____CALLEE__ = ::T.let(nil, ::T.untyped) - SET____ = ::T.let(nil, ::T.untyped) - SET____ETC = ::T.let(nil, ::T.untyped) - SET____ETC_2 = ::T.let(nil, ::T.untyped) - SET____ETC_3 = ::T.let(nil, ::T.untyped) - SET_____2 = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::ProcessedSource - STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::RegexpNode - def fixed_encoding?(); end -end - -module RuboCop::AST::RuboCopCompatibility - INCOMPATIBLE_COPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::Token - def dot?(); end -end - -module RuboCop::AST::Traversal - TYPE_TO_METHOD = ::T.let(nil, ::T.untyped) -end - -module RuboCop::AST::Version - STRING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI - DEFAULT_PARALLEL_OPTIONS = ::T.let(nil, ::T.untyped) - STATUS_ERROR = ::T.let(nil, ::T.untyped) - STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped) - STATUS_OFFENSES = ::T.let(nil, ::T.untyped) - STATUS_SUCCESS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::AutoGenerateConfig - AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped) - PHASE_1 = ::T.let(nil, ::T.untyped) - PHASE_1_DISABLED = ::T.let(nil, ::T.untyped) - PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped) - PHASE_2 = ::T.let(nil, ::T.untyped) - YAML_OPTIONAL_DOC_START = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::ExecuteRunner - INTEGRATION_FORMATTERS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::InitDotfile - DOTFILE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CLI::Command::SuggestExtensions - INCLUDED_FORMATTERS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::CacheConfig -end - -class RuboCop::CacheConfig - def self.root_dir(); end -end - -class RuboCop::Config - DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigFinder - DEFAULT_FILE = ::T.let(nil, ::T.untyped) - DOTFILE = ::T.let(nil, ::T.untyped) - RUBOCOP_HOME = ::T.let(nil, ::T.untyped) - XDG_CONFIG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigFinder - extend ::RuboCop::FileFinder - def self.find_config_path(target_dir); end - - def self.project_root(); end - - def self.project_root=(project_root); end -end - -class RuboCop::ConfigLoader - DEFAULT_FILE = ::T.let(nil, ::T.untyped) - DOTFILE = ::T.let(nil, ::T.untyped) - RUBOCOP_HOME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigLoader - extend ::RuboCop::FileFinder -end - -class RuboCop::ConfigObsoletion - COP_RULE_CLASSES = ::T.let(nil, ::T.untyped) - DEFAULT_RULES_FILE = ::T.let(nil, ::T.untyped) - PARAMETER_RULE_CLASSES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigObsoletion::ChangedEnforcedStyles - BASE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigObsoletion::ChangedParameter - BASE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigObsoletion::RemovedCop - BASE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigRegeneration - AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped) - COMMAND_REGEX = ::T.let(nil, ::T.untyped) - DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ConfigValidator - COMMON_PARAMS = ::T.let(nil, ::T.untyped) - INTERNAL_PARAMS = ::T.let(nil, ::T.untyped) - NEW_COPS_VALUES = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Alignment - SPACE = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::AllowedIdentifiers - SIGILS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::AmbiguousCopName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Base - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::DuplicatedGem - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::GemComment - CHECKED_OPTIONS_CONFIG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICTIVE_VERSION_PATTERN = ::T.let(nil, ::T.untyped) - RESTRICTIVE_VERSION_SPECIFIERS_OPTION = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - VERSION_SPECIFIERS_OPTION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::GemFilename - GEMFILE_FILES = ::T.let(nil, ::T.untyped) - GEMS_RB_FILES = ::T.let(nil, ::T.untyped) - MSG_GEMFILE_MISMATCHED = ::T.let(nil, ::T.untyped) - MSG_GEMFILE_REQUIRED = ::T.let(nil, ::T.untyped) - MSG_GEMS_RB_MISMATCHED = ::T.let(nil, ::T.untyped) - MSG_GEMS_RB_REQUIRED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::GemVersion - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - REQUIRED_MSG = ::T.let(nil, ::T.untyped) - VERSION_SPECIFICATION_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::InsecureProtocolSource - MSG = ::T.let(nil, ::T.untyped) - MSG_HTTP_PROTOCOL = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Bundler::OrderedGems - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::CodeLength - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::CommentsHelp - def comments_in_range(node); end -end - -module RuboCop::Cop::ConfigurableNaming - FORMATS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::ConfigurableNumbering - FORMATS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Corrector - NOOP_CONSUMER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::EachToForCorrector - CORRECTION_WITHOUT_ARGUMENTS = ::T.let(nil, ::T.untyped) - CORRECTION_WITH_ARGUMENTS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::EndKeywordAlignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::ForToEachCorrector - CORRECTION = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::FrozenStringLiteral - FROZEN_STRING_LITERAL = ::T.let(nil, ::T.untyped) - FROZEN_STRING_LITERAL_ENABLED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::DependencyVersion - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - REQUIRED_MSG = ::T.let(nil, ::T.untyped) - VERSION_SPECIFICATION_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::DuplicatedAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::OrderedDependencies - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::RequireMFA - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::RequiredRubyVersion - MISSING_MSG = ::T.let(nil, ::T.untyped) - NOT_EQUAL_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator - CONFIGURATION_ADDED_MESSAGE = ::T.let(nil, ::T.untyped) - SOURCE_TEMPLATE = ::T.let(nil, ::T.untyped) - SPEC_TEMPLATE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator::ConfigurationInjector - TEMPLATE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Generator::RequireFileInjector - REQUIRE_PATH = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::HashShorthandSyntax - EXPLICIT_HASH_VALUE_MSG = ::T.let(nil, ::T.untyped) - OMIT_HASH_VALUE_MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::HashTransformMethod - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Heredoc - OPENING_DELIMITER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::IfThenCorrector - DEFAULT_INDENTATION_WIDTH = ::T.let(nil, ::T.untyped) -end - -RuboCop::Cop::IgnoredPattern = RuboCop::Cop::AllowedPattern - -class RuboCop::Cop::Layout::AccessModifierIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ArgumentAlignment - ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ArrayAlignment - ALIGN_ELEMENTS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::AssignmentIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::BeginEndAlignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::BlockAlignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::BlockEndNewline - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::CaseIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClassStructure - HUMANIZED_NODE_TYPE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClosingHeredocIndentation - MSG = ::T.let(nil, ::T.untyped) - MSG_ARG = ::T.let(nil, ::T.untyped) - SIMPLE_HEREDOC = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ClosingParenthesisIndentation - MSG_ALIGN = ::T.let(nil, ::T.untyped) - MSG_INDENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::CommentIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ConditionPosition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::DefEndAlignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ElseAlignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyComment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineAfterGuardClause - END_OF_HEREDOC_LINE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineAfterMagicComment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLineBetweenDefs - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLines - LINE_OFFSET = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier - MSG_AFTER = ::T.let(nil, ::T.untyped) - MSG_AFTER_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) - MSG_BEFORE_AND_AFTER = ::T.let(nil, ::T.untyped) - MSG_BEFORE_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundArguments - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody - KIND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Layout::EmptyLinesAroundBody - MSG_DEFERRED = ::T.let(nil, ::T.untyped) - MSG_EXTRA = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundClassBody - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody - KIND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::EndOfLine - MSG_DETECTED = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::ExtraSpacing - MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped) - MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArgumentIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArrayElementIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstArrayElementLineBreak - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstHashElementIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstHashElementLineBreak - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstMethodParameterLineBreak - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::FirstParameterIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HashAlignment - MESSAGES = ::T.let(nil, ::T.untyped) - SEPARATOR_ALIGNMENT_STYLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::HeredocIndentation - TYPE_MSG = ::T.let(nil, ::T.untyped) - WIDTH_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationConsistency - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationStyle - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::IndentationWidth - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::InitialIndentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LeadingCommentSpace - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LeadingEmptyLines - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation - MSG_ALIGN = ::T.let(nil, ::T.untyped) - MSG_INDENT = ::T.let(nil, ::T.untyped) - PARENT_TYPES_FOR_INDENTED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::LineLength - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineArrayBraceLayout - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineArrayLineBreaks - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineAssignmentLayout - NEW_LINE_OFFENSE = ::T.let(nil, ::T.untyped) - SAME_LINE_OFFENSE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineBlockLayout - ARG_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PIPE_SIZE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineHashBraceLayout - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout - ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) - SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks - include ::RuboCop::Cop::MultilineElementLineBreaks - def on_def(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks - extend ::RuboCop::Cop::AutoCorrector -end - -class RuboCop::Cop::Layout::ParameterAlignment - ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) - FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::RedundantLineBreak - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::RescueEnsureAlignment - ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) - ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) - ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SingleLineBlockChain - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterColon - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterMethodName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAfterNot - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundKeyword - ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped) - ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped) - ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) - DO = ::T.let(nil, ::T.untyped) - MSG_AFTER = ::T.let(nil, ::T.untyped) - MSG_BEFORE = ::T.let(nil, ::T.untyped) - NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) - SAFE_NAVIGATION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator - MSG = ::T.let(nil, ::T.untyped) - SPACES_REGEXP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceAroundOperators - EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped) - IRREGULAR_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeBlockBraces - DETECTED_MSG = ::T.let(nil, ::T.untyped) - MISSING_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeBrackets - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeComment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceBeforeFirstArg - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInLambdaLiteral - MSG_REQUIRE_NO_SPACE = ::T.let(nil, ::T.untyped) - MSG_REQUIRE_SPACE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets - EMPTY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral - MSG = ::T.let(nil, ::T.untyped) - MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideParens - MSG = ::T.let(nil, ::T.untyped) - MSG_SPACE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters - BEGIN_REGEX = ::T.let(nil, ::T.untyped) - END_REGEX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideRangeLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets - EMPTY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::SpaceInsideStringInterpolation - NO_SPACE_MSG = ::T.let(nil, ::T.untyped) - SPACE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Layout::TrailingWhitespace - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousAssignment - MISTAKES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SIMPLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousBlockAssociation - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousOperator - AMBIGUITIES = ::T.let(nil, ::T.untyped) - MSG_FORMAT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence - MSG = ::T.let(nil, ::T.untyped) - PRECEDENCE = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousRange - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AmbiguousRegexpLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::AssignmentInCondition - ASGN_TYPES = ::T.let(nil, ::T.untyped) - MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) - MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::BigDecimalNew - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands - ALLOWED_MATH_OPERATORS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::BooleanSymbol - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::CircularArgumentReference - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ConstantDefinitionInBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ConstantOverwrittenInRescue - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ConstantResolution - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Debugger - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DeprecatedClassMethods - CLASS_METHOD_DELIMETER = ::T.let(nil, ::T.untyped) - DEPRECATED_METHODS_OBJECT = ::T.let(nil, ::T.untyped) - INSTANCE_METHOD_DELIMETER = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DeprecatedConstants - DO_NOT_USE_MSG = ::T.let(nil, ::T.untyped) - SUGGEST_GOOD_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DeprecatedOpenSSLConstant - MSG = ::T.let(nil, ::T.untyped) - NO_ARG_ALGORITHM = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateBranch - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateCaseCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateElsifCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateHashKey - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateMethods - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement - MSG_REPEATED_ELEMENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateRequire - MSG = ::T.let(nil, ::T.untyped) - REQUIRE_METHODS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::DuplicateRescueException - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EachWithObjectArgument - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ElseLayout - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyClass - CLASS_MSG = ::T.let(nil, ::T.untyped) - METACLASS_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyConditionalBody - include ::RuboCop::Cop::RangeHelp - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyConditionalBody - extend ::RuboCop::Cop::AutoCorrector -end - -class RuboCop::Cop::Lint::EmptyEnsure - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyExpression - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyFile - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyInPattern - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyInterpolation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EmptyWhen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::EnsureReturn - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ErbNewArguments - MESSAGES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FlipFlop - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FloatComparison - EQUALITY_METHODS = ::T.let(nil, ::T.untyped) - FLOAT_INSTANCE_METHODS = ::T.let(nil, ::T.untyped) - FLOAT_RETURNING_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FloatOutOfRange - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::FormatParameterMismatch - KERNEL = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - MSG_INVALID = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SHOVEL = ::T.let(nil, ::T.untyped) - STRING_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::HashCompareByIdentity - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::HeredocMethodCallPosition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::IdentityComparison - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ImplicitStringConcatenation - FOR_ARRAY = ::T.let(nil, ::T.untyped) - FOR_METHOD = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::IneffectiveAccessModifier - ALTERNATIVE_PRIVATE = ::T.let(nil, ::T.untyped) - ALTERNATIVE_PROTECTED = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::InheritException - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_BASE_CLASS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::InterpolationCheck - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::LambdaWithoutLiteralBlock - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::LiteralAsCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::LiteralInInterpolation - COMPOSITE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Loop - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MissingCopEnableDirective - MSG = ::T.let(nil, ::T.untyped) - MSG_BOUND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MissingSuper - CALLBACKS = ::T.let(nil, ::T.untyped) - CALLBACK_MSG = ::T.let(nil, ::T.untyped) - CLASS_LIFECYCLE_CALLBACKS = ::T.let(nil, ::T.untyped) - CONSTRUCTOR_MSG = ::T.let(nil, ::T.untyped) - METHOD_LIFECYCLE_CALLBACKS = ::T.let(nil, ::T.untyped) - STATELESS_CLASSES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MixedRegexpCaptureTypes - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::MultipleComparison - COMPARISON_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SET_OPERATION_OPERATORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NestedMethodDefinition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NestedPercentLiteral - MSG = ::T.let(nil, ::T.untyped) - PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) - REGEXES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NextWithoutAccumulator - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NoReturnInBeginEndBlocks - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NonAtomicFileOperation - MAKE_FORCE_METHODS = ::T.let(nil, ::T.untyped) - MAKE_METHODS = ::T.let(nil, ::T.untyped) - MSG_CHANGE_FORCE_METHOD = ::T.let(nil, ::T.untyped) - MSG_REMOVE_FILE_EXIST_CHECK = ::T.let(nil, ::T.untyped) - REMOVE_FORCE_METHODS = ::T.let(nil, ::T.untyped) - REMOVE_METHODS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NonDeterministicRequireOrder - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NonLocalExitFromIterator - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NumberConversion - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - CONVERSION_METHODS = ::T.let(nil, ::T.untyped) - CONVERSION_METHOD_CLASS_MAPPING = ::T.let(nil, ::T.untyped) - METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::NumberedParameterAssignment - LVAR_MSG = ::T.let(nil, ::T.untyped) - NUMBERED_PARAMETER_RANGE = ::T.let(nil, ::T.untyped) - NUM_PARAM_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::OrAssignmentToConstant - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::OrderedMagicComments - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::OutOfRangeRegexpRef - MSG = ::T.let(nil, ::T.untyped) - REGEXP_ARGUMENT_METHODS = ::T.let(nil, ::T.untyped) - REGEXP_CAPTURE_METHODS = ::T.let(nil, ::T.untyped) - REGEXP_RECEIVER_METHODS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::PercentStringArray - LEADING_QUOTE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - QUOTES_AND_COMMAS = ::T.let(nil, ::T.untyped) - TRAILING_QUOTE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::PercentSymbolArray - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RaiseException - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RandOne - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantCopDisableDirective - COP_NAME = ::T.let(nil, ::T.untyped) - DEPARTMENT_MARKER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantCopEnableDirective - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantDirGlobSort - GLOB_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantRequireStatement - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantSafeNavigation - MSG = ::T.let(nil, ::T.untyped) - NIL_SPECIFIC_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantSplatExpansion - ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped) - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped) - PERCENT_I = ::T.let(nil, ::T.untyped) - PERCENT_W = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantStringCoercion - MSG_DEFAULT = ::T.let(nil, ::T.untyped) - MSG_SELF = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantWithIndex - MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped) - MSG_WITH_INDEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RedundantWithObject - MSG_EACH_WITH_OBJECT = ::T.let(nil, ::T.untyped) - MSG_WITH_OBJECT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RefinementImportMethods - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RegexpAsCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RequireParentheses - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RequireRangeParentheses - def on_erange(node); end - - def on_irange(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RequireRangeParentheses -end - -class RuboCop::Cop::Lint::RequireRelativeSelfPath - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RescueException - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::RescueType - INVALID_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ReturnInVoidContext - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationChain - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationChain - extend ::RuboCop::Cop::AutoCorrector -end - -class RuboCop::Cop::Lint::SafeNavigationConsistency - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SafeNavigationWithEmpty - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ScriptPermission - MSG = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SelfAssignment - ASSIGNMENT_TYPE_TO_RHS_TYPE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SendWithMixinArgument - MIXIN_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SEND_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowedArgument - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowedException - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ShadowingOuterLocalVariable - def find_conditional_node_from_ascendant(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::StructNewOverride - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - STRUCT_MEMBER_NAME_TYPES = ::T.let(nil, ::T.untyped) - STRUCT_METHOD_NAMES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SuppressedException - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::SymbolConversion - MSG = ::T.let(nil, ::T.untyped) - MSG_CONSISTENCY = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ToEnumArguments - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::ToJSON - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::TopLevelReturnWithArgument - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::TripleQuotes - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnderscorePrefixedVariableName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnexpectedBlockArity - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnifiedInteger - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnmodifiedReduceAccumulator - MSG = ::T.let(nil, ::T.untyped) - MSG_INDEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnreachableCode - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UnreachableLoop - CONTINUE_KEYWORDS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UriEscapeUnescape - ALTERNATE_METHODS_OF_URI_ESCAPE = ::T.let(nil, ::T.untyped) - ALTERNATE_METHODS_OF_URI_UNESCAPE = ::T.let(nil, ::T.untyped) - METHOD_NAMES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UriRegexp - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - URI_CONSTANTS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessAccessModifier - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessElseWithoutRescue - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessMethodDefinition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessRuby2Keywords - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessSetterCall - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::UselessTimes - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Lint::Void - BINARY_OPERATORS = ::T.let(nil, ::T.untyped) - DEFINED_MSG = ::T.let(nil, ::T.untyped) - LIT_MSG = ::T.let(nil, ::T.untyped) - NONMUTATING_METHODS = ::T.let(nil, ::T.untyped) - NONMUTATING_MSG = ::T.let(nil, ::T.untyped) - OPERATORS = ::T.let(nil, ::T.untyped) - OP_MSG = ::T.let(nil, ::T.untyped) - SELF_MSG = ::T.let(nil, ::T.untyped) - UNARY_OPERATORS = ::T.let(nil, ::T.untyped) - VAR_MSG = ::T.let(nil, ::T.untyped) - VOID_CONTEXT_TYPES = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::MethodComplexity - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern -end - -class RuboCop::Cop::Metrics::AbcSize - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::BlockLength - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - LABEL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::BlockNesting - NESTING_BLOCKS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::CyclomaticComplexity - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - COUNTED_NODES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::MethodLength - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - LABEL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::ParameterLists - MSG = ::T.let(nil, ::T.untyped) - OPTIONAL_PARAMETERS_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::PerceivedComplexity - COUNTED_NODES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator - include ::RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount - include ::RuboCop::AST::Sexp -end - -module RuboCop::Cop::Metrics::Utils::IteratingBlock - KNOWN_ITERATING_METHODS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Metrics::Utils::RepeatedAttributeDiscount - VAR_SETTER_TO_GETTER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Migration::DepartmentName - DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped) - DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::MultilineExpressionIndentation - ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - DEFAULT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - KEYWORD_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) - KEYWORD_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) - UNALIGNED_RHS_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::AccessorMethodName - MSG_READER = ::T.let(nil, ::T.untyped) - MSG_WRITER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::AsciiIdentifiers - CONSTANT_MSG = ::T.let(nil, ::T.untyped) - IDENTIFIER_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::BinaryOperatorParameterName - EXCLUDED = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - OP_LIKE_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::BlockForwarding - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::ClassAndModuleCamelCase - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::ConstantName - MSG = ::T.let(nil, ::T.untyped) - SNAKE_CASE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::FileName - MSG_NO_DEFINITION = ::T.let(nil, ::T.untyped) - MSG_REGEX = ::T.let(nil, ::T.untyped) - MSG_SNAKE_CASE = ::T.let(nil, ::T.untyped) - SNAKE_CASE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::HeredocDelimiterCase - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::HeredocDelimiterNaming - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::InclusiveLanguage - EMPTY_ARRAY = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - MSG_FOR_FILE_PATH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::MemoizedInstanceVariableName - DYNAMIC_DEFINE_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE_REQUIRED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::MethodName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::RescuedExceptionsVariableName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::VariableName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Naming::VariableNumber - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::NegativeConditional - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Offense - COMPARISON_ATTRIBUTES = ::T.let(nil, ::T.untyped) - NO_LOCATION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::OrderedGemCorrector - extend ::RuboCop::Cop::OrderedGemNode - extend ::RuboCop::Cop::RangeHelp -end - -class RuboCop::Cop::ParenthesesCorrector - extend ::RuboCop::Cop::RangeHelp -end - -class RuboCop::Cop::Performance::AncestorsInclude - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ArraySemiInfiniteRangeSlice - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SLICE_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::BigDecimalWithNumericArgument - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::BindCall - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::BlockGivenWithExplicitBlock - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Caller - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Casecmp - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ChainArrayAllocation - RETURNS_NEW_ARRAY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::CollectionLiteralInLoop - ARRAY_METHODS = ::T.let(nil, ::T.untyped) - ENUMERABLE_METHOD_NAMES = ::T.let(nil, ::T.untyped) - HASH_METHODS = ::T.let(nil, ::T.untyped) - LOOP_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - NONMUTATING_ARRAY_METHODS = ::T.let(nil, ::T.untyped) - NONMUTATING_HASH_METHODS = ::T.let(nil, ::T.untyped) - POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ConcurrentMonotonicTime - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ConstantRegexp - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Count - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeletePrefix - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeleteSuffix - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Detect - CANDIDATE_METHODS = ::T.let(nil, ::T.untyped) - INDEX_MSG = ::T.let(nil, ::T.untyped) - INDEX_REVERSE_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::EndWith - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FixedSize - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FlatMap - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::InefficientHashSearch - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::IoReadlines - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::MapCompact - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::MethodObjectAsBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::OpenStruct - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RangeInclude - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock - COMPARISON_METHODS = ::T.let(nil, ::T.untyped) - IS_A_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TARGET_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMatch - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMerge - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantSortBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantSplitRegexpArgument - DETERMINISTIC_REGEX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - STR_SPECIAL_CHARS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantStringChars - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ReverseEach - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ReverseFirst - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::SelectMap - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Size - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::SortReverse - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Squeeze - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_METHODS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StartWith - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StringIdentifierArgument - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StringInclude - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StringReplacement - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Sum - MSG = ::T.let(nil, ::T.untyped) - MSG_IF_NO_INIT_VALUE = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::TimesMap - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UnfreezeString - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UriDefaultParser - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::PreferredDelimiters - PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AlignLeftLetBrace - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AlignRightLetBrace - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AnyInstance - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::AroundBlock - MSG_NO_ARG = ::T.let(nil, ::T.untyped) - MSG_UNUSED_ARG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Be - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeEq - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeEql - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeNil - BE_MSG = ::T.let(nil, ::T.untyped) - BE_NIL_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::BeforeAfterAll - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::FeatureMethods - MAP = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::SpecificMatcher - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SPECIFIC_MATCHER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher - CAPYBARA_MATCHER_METHODS = ::T.let(nil, ::T.untyped) - MSG_FALSE = ::T.let(nil, ::T.untyped) - MSG_TRUE = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ChangeByZero - MSG = ::T.let(nil, ::T.untyped) - MSG_COMPOUND = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ContextMethod - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ContextWording - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeClass - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeMethod - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribeSymbol - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribedClass - DESCRIBED_CLASS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::DescribedClassModuleWrapping - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Dialect - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyExampleGroup - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyHook - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExample - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterHook - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::EmptyLineAfterSubject - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleLength - LABEL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleWithoutDescription - MSG_ADD_DESCRIPTION = ::T.let(nil, ::T.untyped) - MSG_DEFAULT_ARGUMENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExampleWording - IT_PREFIX = ::T.let(nil, ::T.untyped) - MSG_IT = ::T.let(nil, ::T.untyped) - MSG_SHOULD = ::T.let(nil, ::T.untyped) - SHOULD_PREFIX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectActual - COMPLEX_LITERALS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SIMPLE_LITERALS = ::T.let(nil, ::T.untyped) - SUPPORTED_MATCHERS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectChange - MSG_BLOCK = ::T.let(nil, ::T.untyped) - MSG_CALL = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectInHook - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ExpectOutput - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RSpec::ExplicitHelper - BUILT_IN_MATCHERS = ::T.let(nil, ::T.untyped) - MSG_EXPLICIT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::CreateList - MSG_CREATE_LIST = ::T.let(nil, ::T.untyped) - MSG_N_TIMES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName - ALLOWED_CONSTANTS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FactoryBot::SyntaxMethods - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::FilePath - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Focus - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::HookArgument - EXPLICIT_MSG = ::T.let(nil, ::T.untyped) - IMPLICIT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::HooksBeforeExamples - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::IdenticalEqualityAssertion - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitBlockExpectation - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitExpect - ENFORCED_REPLACEMENTS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ImplicitSubject - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RSpec::InflectedHelper - MSG_INFLECTED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::InstanceSpy - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::InstanceVariable - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ItBehavesLike - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::IteratedExpectation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LeadingSubject - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LeakyConstantDeclaration - MSG_CLASS = ::T.let(nil, ::T.untyped) - MSG_CONST = ::T.let(nil, ::T.untyped) - MSG_MODULE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LetBeforeExamples - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::LetSetup - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageChain - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageExpectation - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - SUPPORTED_STYLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MessageSpies - MSG_HAVE_RECEIVED = ::T.let(nil, ::T.untyped) - MSG_RECEIVE = ::T.let(nil, ::T.untyped) - SUPPORTED_STYLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MissingExampleGroupArgument - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleDescribes - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleExpectations - ANYTHING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TRUE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleMemoizedHelpers - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::MultipleSubjects - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NamedSubject - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NestedGroups - DEPRECATED_MAX_KEY = ::T.let(nil, ::T.untyped) - DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::NotToNot - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::OverwritingSetup - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Pending - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Rails::AvoidSetupHook - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Rails::HaveHttpStatus - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReceiveCounts - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReceiveNever - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedDescription - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExample - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupBody - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::RepeatedIncludeExample - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReturnFromStub - MSG_AND_RETURN = ::T.let(nil, ::T.untyped) - MSG_BLOCK = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector - NULL_BLOCK_BODY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ScatteredLet - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::ScatteredSetup - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SharedContext - MSG_CONTEXT = ::T.let(nil, ::T.untyped) - MSG_EXAMPLES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SharedExamples::Checker - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SingleArgumentMessageChain - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::StubbedMock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SubjectDeclaration - MSG_LET = ::T.let(nil, ::T.untyped) - MSG_REDUNDANT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::SubjectStub - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::UnspecifiedException - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RSpec::Variable::Helpers -end - -module RuboCop::Cop::RSpec::Variable::Helpers - def self.all(element); end -end - -module RuboCop::Cop::RSpec::Variable::Subjects -end - -module RuboCop::Cop::RSpec::Variable::Subjects - def self.all(element); end -end - -class RuboCop::Cop::RSpec::VariableDefinition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VariableName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VerifiedDoubleReference - MSG = ::T.let(nil, ::T.untyped) - REFERENCE_TYPE_STYLES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VerifiedDoubles - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::VoidExpect - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::RSpec::Yield - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Rake::ClassDefinitionInTask - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Rake::Desc - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Rake::DuplicateNamespace - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Rake::DuplicateTask - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Rake::MethodDefinitionInTask - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::RangeHelp - BYTE_ORDER_MARK = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::CompoundHash - COMBINATOR_IN_HASH_MSG = ::T.let(nil, ::T.untyped) - MONUPLE_HASH_MSG = ::T.let(nil, ::T.untyped) - REDUNDANT_HASH_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::Eval - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::IoMethods - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::JSONLoad - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::MarshalLoad - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::Open - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Security::YAMLLoad - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Severity - CODE_TABLE = ::T.let(nil, ::T.untyped) - NAMES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::CallbackConditionalsBinding - CALLBACKS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::EnforceSigilOrder - CODING_REGEX = ::T.let(nil, ::T.untyped) - FROZEN_REGEX = ::T.let(nil, ::T.untyped) - INDENT_REGEX = ::T.let(nil, ::T.untyped) - MAGIC_REGEX = ::T.let(nil, ::T.untyped) - PREFERRED_ORDER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::ForbidExtendTSigHelpersInShims - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::ForbidIncludeConstLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::ForbidSuperclassConstLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::ForbidUntypedStructProps - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::OneAncestorPerLine - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::SignatureBuildOrder - ORDER = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::SingleLineRbiClassModuleDefinitions - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::TypeAliasName - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Sorbet::ValidSigil - SIGIL_REGEX = ::T.let(nil, ::T.untyped) - STRICTNESS_LEVELS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SpaceAfterPunctuation - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SpaceBeforePunctuation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AccessModifierDeclarations - GROUP_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) - INLINE_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AccessorGrouping - ACCESSOR_METHODS = ::T.let(nil, ::T.untyped) - GROUPED_MSG = ::T.let(nil, ::T.untyped) - SEPARATED_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Alias - MSG_ALIAS = ::T.let(nil, ::T.untyped) - MSG_ALIAS_METHOD = ::T.let(nil, ::T.untyped) - MSG_SYMBOL_ARGS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AndOr - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ArgumentsForwarding - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ArrayCoercion - CHECK_MSG = ::T.let(nil, ::T.untyped) - SPLAT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ArrayJoin - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AsciiComments - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Attr - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::AutoResourceCleanup - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - TARGET_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BarePercentLiterals - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BeginBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BisectedAttrAccessor - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BlockComments - BEGIN_LENGTH = ::T.let(nil, ::T.untyped) - END_LENGTH = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::BlockDelimiters - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped) - BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CaseCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper -end - -class RuboCop::Cop::Style::CaseEquality - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CaseLikeIf - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CharacterLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassAndModuleChildren - COMPACT_MSG = ::T.let(nil, ::T.untyped) - NESTED_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassCheck - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassEqualityComparison - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassMethods - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassMethodsDefinitions - MSG = ::T.let(nil, ::T.untyped) - MSG_SCLASS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ClassVars - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CollectionCompact - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CollectionMethods - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ColonMethodCall - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ColonMethodDefinition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CombinableLoops - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommandLiteral - MSG_USE_BACKTICKS = ::T.let(nil, ::T.untyped) - MSG_USE_PERCENT_X = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommentAnnotation - MISSING_NOTE = ::T.let(nil, ::T.untyped) - MSG_COLON_STYLE = ::T.let(nil, ::T.untyped) - MSG_SPACE_STYLE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::CommentedKeyword - ALLOWED_COMMENTS = ::T.let(nil, ::T.untyped) - ALLOWED_COMMENT_REGEXES = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - KEYWORD_REGEXES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - REGEXP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ConditionalAssignment - ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - ASSIGN_TO_CONDITION_MSG = ::T.let(nil, ::T.untyped) - ENABLED = ::T.let(nil, ::T.untyped) - INDENTATION_WIDTH = ::T.let(nil, ::T.untyped) - LINE_LENGTH = ::T.let(nil, ::T.untyped) - MAX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SINGLE_LINE_CONDITIONS_ONLY = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - WIDTH = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Style::ConditionalAssignmentHelper - ALIGN_WITH = ::T.let(nil, ::T.untyped) - END_ALIGNMENT = ::T.let(nil, ::T.untyped) - EQUAL = ::T.let(nil, ::T.untyped) - KEYWORD = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ConstantVisibility - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Copyright - AUTOCORRECT_EMPTY_WARNING = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DateTime - CLASS_MSG = ::T.let(nil, ::T.untyped) - COERCION_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DefWithParentheses - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Dir - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective - MSG = ::T.let(nil, ::T.untyped) - MSG_FOR_COPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DocumentDynamicEvalDefinition - BLOCK_COMMENT_REGEXP = ::T.let(nil, ::T.untyped) - COMMENT_REGEXP = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Documentation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DocumentationMethod - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DoubleCopDisableDirective - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::DoubleNegation - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EachForSimpleLoop - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EachWithObject - METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyBlockParameter - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyCaseCondition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyElse - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyHeredoc - include ::RuboCop::Cop::Heredoc - include ::RuboCop::Cop::RangeHelp - def on_heredoc(node); end - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyHeredoc - extend ::RuboCop::Cop::AutoCorrector -end - -class RuboCop::Cop::Style::EmptyLambdaParameter - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyLiteral - ARR_MSG = ::T.let(nil, ::T.untyped) - HASH_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - STR_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EmptyMethod - MSG_COMPACT = ::T.let(nil, ::T.untyped) - MSG_EXPANDED = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Encoding - ENCODING_PATTERN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EndBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EndlessMethod - CORRECTION_STYLES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - MSG_MULTI_LINE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EnvHome - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EvalWithLocation - MSG = ::T.let(nil, ::T.untyped) - MSG_EVAL = ::T.let(nil, ::T.untyped) - MSG_INCORRECT_FILE = ::T.let(nil, ::T.untyped) - MSG_INCORRECT_LINE = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::EvenOdd - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ExpandPathArguments - MSG = ::T.let(nil, ::T.untyped) - PATHNAME_MSG = ::T.let(nil, ::T.untyped) - PATHNAME_NEW_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ExplicitBlockArgument - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ExponentialNotation - MESSAGES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FetchEnvVar - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FileRead - MSG = ::T.let(nil, ::T.untyped) - READ_FILE_START_TO_FINISH_MODES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FileWrite - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - TRUNCATING_WRITE_MODES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FloatDivision - MESSAGES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::For - EACH_LENGTH = ::T.let(nil, ::T.untyped) - PREFER_EACH = ::T.let(nil, ::T.untyped) - PREFER_FOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FormatString - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::FormatStringToken - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern -end - -class RuboCop::Cop::Style::FrozenStringLiteralComment - MSG_DISABLED = ::T.let(nil, ::T.untyped) - MSG_MISSING = ::T.let(nil, ::T.untyped) - MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped) - MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) - SHEBANG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::GlobalStdStream - MSG = ::T.let(nil, ::T.untyped) - STD_STREAMS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::GlobalVars - BUILT_IN_VARS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::GuardClause - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashConversion - MSG_LITERAL_HASH_ARG = ::T.let(nil, ::T.untyped) - MSG_LITERAL_MULTI_ARG = ::T.let(nil, ::T.untyped) - MSG_SPLAT = ::T.let(nil, ::T.untyped) - MSG_TO_H = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashEachMethods - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashExcept - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashLikeCase - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::HashSyntax - MSG_19 = ::T.let(nil, ::T.untyped) - MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped) - MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IdenticalConditionalBranches - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper -end - -class RuboCop::Cop::Style::IfInsideElse - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfUnlessModifier - MSG_USE_MODIFIER = ::T.let(nil, ::T.untyped) - MSG_USE_NORMAL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfWithBooleanLiteralBranches - MSG = ::T.let(nil, ::T.untyped) - MSG_FOR_ELSIF = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IfWithSemicolon - MSG_IF_ELSE = ::T.let(nil, ::T.untyped) - MSG_TERNARY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ImplicitRuntimeError - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InPatternThen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InfiniteLoop - LEADING_SPACE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InlineComment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::InverseMethods - CAMEL_CASE = ::T.let(nil, ::T.untyped) - CLASS_COMPARISON_METHODS = ::T.let(nil, ::T.untyped) - EQUALITY_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::IpAddresses - IPV6_MAX_SIZE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::KeywordParametersOrder - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Lambda - LITERAL_MESSAGE = ::T.let(nil, ::T.untyped) - METHOD_MESSAGE = ::T.let(nil, ::T.untyped) - OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::LambdaCall - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::LineEndConcatenation - COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped) - COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped) - CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped) - HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped) - SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MapCompactWithConditionalBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MapToHash - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodCallWithArgsParentheses - include ::RuboCop::Cop::AllowedMethods -end - -module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses - TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodCalledOnDoEndBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MethodDefParentheses - MSG_MISSING = ::T.let(nil, ::T.untyped) - MSG_PRESENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MinMax - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MissingElse - MSG = ::T.let(nil, ::T.untyped) - MSG_EMPTY = ::T.let(nil, ::T.untyped) - MSG_NIL = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MissingRespondToMissing - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MixinGrouping - MIXIN_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MixinUsage - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ModuleFunction - EXTEND_SELF_MSG = ::T.let(nil, ::T.untyped) - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - MODULE_FUNCTION_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineBlockChain - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineIfModifier - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineIfThen - MSG = ::T.let(nil, ::T.untyped) - NON_MODIFIER_THEN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineInPatternThen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineMemoization - BRACES_MSG = ::T.let(nil, ::T.untyped) - KEYWORD_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineMethodSignature - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineTernaryOperator - MSG_IF = ::T.let(nil, ::T.untyped) - MSG_SINGLE_LINE = ::T.let(nil, ::T.untyped) - SINGLE_LINE_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultilineWhenThen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MultipleComparison - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::MutableConstant - include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NegatedIfElseCondition - MSG = ::T.let(nil, ::T.untyped) - NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedFileDirname - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedModifier - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedParenthesizedCalls - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NestedTernaryOperator - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Next - EXIT_TYPES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NilComparison - EXPLICIT_MSG = ::T.let(nil, ::T.untyped) - PREDICATE_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NilLambda - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NonNilCheck - MSG_FOR_REDUNDANCY = ::T.let(nil, ::T.untyped) - MSG_FOR_REPLACEMENT = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Not - MSG = ::T.let(nil, ::T.untyped) - OPPOSITE_METHODS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumberedParameters - MSG_DISALLOW = ::T.let(nil, ::T.untyped) - MSG_MULTI_LINE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumberedParametersLimit - DEFAULT_MAX_VALUE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericLiteralPrefix - BINARY_MSG = ::T.let(nil, ::T.untyped) - BINARY_REGEX = ::T.let(nil, ::T.untyped) - DECIMAL_MSG = ::T.let(nil, ::T.untyped) - DECIMAL_REGEX = ::T.let(nil, ::T.untyped) - HEX_MSG = ::T.let(nil, ::T.untyped) - HEX_REGEX = ::T.let(nil, ::T.untyped) - OCTAL_MSG = ::T.let(nil, ::T.untyped) - OCTAL_REGEX = ::T.let(nil, ::T.untyped) - OCTAL_ZERO_ONLY_MSG = ::T.let(nil, ::T.untyped) - OCTAL_ZERO_ONLY_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericLiterals - include ::RuboCop::Cop::AllowedPattern - DELIMITER_REGEXP = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::NumericPredicate - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) - REPLACEMENTS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ObjectThen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OneLineConditional - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OpenStructUse - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OptionHash - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OptionalArguments - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OptionalBooleanParameter - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::OrAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ParallelAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PercentQLiterals - LOWER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) - UPPER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PerlBackrefs - MESSAGE_FORMAT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::PreferredHashMethods - MSG = ::T.let(nil, ::T.untyped) - OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Proc - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::QuotedSymbols - MSG_DOUBLE = ::T.let(nil, ::T.untyped) - MSG_SINGLE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RaiseArgs - COMPACT_MSG = ::T.let(nil, ::T.untyped) - EXPLODED_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RandomWithOffset - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantArgument - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantAssignment - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantBegin - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantCapitalW - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantCondition - MSG = ::T.let(nil, ::T.untyped) - REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantConditional - COMPARISON_OPERATOR_MATCHER = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantException - MSG_1 = ::T.let(nil, ::T.untyped) - MSG_2 = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantFetchBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantFileExtensionInRequire - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantFreeze - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantInitialize - MSG = ::T.let(nil, ::T.untyped) - MSG_EMPTY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantInterpolation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantPercentQ - DYNAMIC_MSG = ::T.let(nil, ::T.untyped) - EMPTY = ::T.let(nil, ::T.untyped) - ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped) - PERCENT_Q = ::T.let(nil, ::T.untyped) - QUOTE = ::T.let(nil, ::T.untyped) - SINGLE_QUOTE = ::T.let(nil, ::T.untyped) - STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantRegexpCharacterClass - MSG_REDUNDANT_CHARACTER_CLASS = ::T.let(nil, ::T.untyped) - REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantRegexpEscape - ALLOWED_ALWAYS_ESCAPES = ::T.let(nil, ::T.untyped) - ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = ::T.let(nil, ::T.untyped) - ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = ::T.let(nil, ::T.untyped) - MSG_REDUNDANT_ESCAPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantReturn - MSG = ::T.let(nil, ::T.untyped) - MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSelf - KERNEL_METHODS = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSelfAssignment - ASSIGNMENT_TYPE_TO_RECEIVER_TYPE = ::T.let(nil, ::T.untyped) - METHODS_RETURNING_SELF = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSelfAssignmentBranch - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSort - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RedundantSortBy - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RegexpLiteral - MSG_USE_PERCENT_R = ::T.let(nil, ::T.untyped) - MSG_USE_SLASHES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RescueModifier - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::RescueStandardError - MSG_EXPLICIT = ::T.let(nil, ::T.untyped) - MSG_IMPLICIT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ReturnNil - RETURN_MSG = ::T.let(nil, ::T.untyped) - RETURN_NIL_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SafeNavigation - LOGIC_JUMP_KEYWORDS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Sample - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SelectByRegexp - MSG = ::T.let(nil, ::T.untyped) - REGEXP_METHODS = ::T.let(nil, ::T.untyped) - REPLACEMENTS = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SelfAssignment - MSG = ::T.let(nil, ::T.untyped) - OPS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Semicolon - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Send - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SignalException - FAIL_MSG = ::T.let(nil, ::T.untyped) - RAISE_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SingleArgumentDig - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SingleLineBlockParams - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SingleLineMethods - MSG = ::T.let(nil, ::T.untyped) - NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SlicingWithRange - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SoleNestedConditional - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SpecialGlobalVars - BUILTIN_VARS = ::T.let(nil, ::T.untyped) - ENGLISH_VARS = ::T.let(nil, ::T.untyped) - LIBRARY_NAME = ::T.let(nil, ::T.untyped) - MSG_BOTH = ::T.let(nil, ::T.untyped) - MSG_ENGLISH = ::T.let(nil, ::T.untyped) - MSG_REGULAR = ::T.let(nil, ::T.untyped) - NON_ENGLISH_VARS = ::T.let(nil, ::T.untyped) - PERL_VARS = ::T.let(nil, ::T.untyped) - STYLE_VARS_MAP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StabbyLambdaParentheses - MSG_NO_REQUIRE = ::T.let(nil, ::T.untyped) - MSG_REQUIRE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StaticClass - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StderrPuts - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringChars - BAD_ARGUMENTS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringConcatenation - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringHashKeys - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringLiterals - MSG_INCONSISTENT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StringMethods - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::Strip - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::StructInheritance - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SwapValues - MSG = ::T.let(nil, ::T.untyped) - SIMPLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolArray - ARRAY_MSG = ::T.let(nil, ::T.untyped) - PERCENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolLiteral - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::SymbolProc - include ::RuboCop::Cop::AllowedMethods - include ::RuboCop::Cop::AllowedPattern - MSG = ::T.let(nil, ::T.untyped) - SUPER_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TernaryCorrector - extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper - extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper -end - -class RuboCop::Cop::Style::TernaryParentheses - MSG = ::T.let(nil, ::T.untyped) - MSG_COMPLEX = ::T.let(nil, ::T.untyped) - NON_COMPLEX_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TopLevelMethodDefinition - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnClass - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingBodyOnModule - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingCommaInBlockArgs - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingMethodEndStatement - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrailingUnderscoreVariable - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::TrivialAccessors - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::UnlessElse - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::UnlessLogicalOperators - FORBID_LOGICAL_OPERATORS = ::T.let(nil, ::T.untyped) - FORBID_MIXED_LOGICAL_OPERATORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::UnpackFirst - MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::VariableInterpolation - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhenThen - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhileUntilDo - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WhileUntilModifier - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::WordArray - ARRAY_MSG = ::T.let(nil, ::T.untyped) - PERCENT_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::YodaCondition - EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped) - PROGRAM_NAMES = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - REVERSE_COMPARISON = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Style::ZeroLengthPredicate - NONZERO_MSG = ::T.let(nil, ::T.untyped) - RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped) - ZERO_MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::SurroundingSpace - NO_SPACE_COMMAND = ::T.let(nil, ::T.untyped) - SINGLE_SPACE_REGEXP = ::T.let(nil, ::T.untyped) - SPACE_COMMAND = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::TrailingComma - MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::UncommunicativeName - CASE_MSG = ::T.let(nil, ::T.untyped) - FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) - LENGTH_MSG = ::T.let(nil, ::T.untyped) - NUM_MSG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::Util - LITERAL_REGEX = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Utils::FormatString - DIGIT_DOLLAR = ::T.let(nil, ::T.untyped) - FLAG = ::T.let(nil, ::T.untyped) - NAME = ::T.let(nil, ::T.untyped) - NUMBER = ::T.let(nil, ::T.untyped) - NUMBER_ARG = ::T.let(nil, ::T.untyped) - PRECISION = ::T.let(nil, ::T.untyped) - SEQUENCE = ::T.let(nil, ::T.untyped) - TEMPLATE_NAME = ::T.let(nil, ::T.untyped) - TYPE = ::T.let(nil, ::T.untyped) - WIDTH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce - ARGUMENT_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) - LOGICAL_OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - LOOP_TYPES = ::T.let(nil, ::T.untyped) - MULTIPLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) - OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped) - REGEXP_NAMED_CAPTURE_TYPE = ::T.let(nil, ::T.untyped) - RESCUE_TYPE = ::T.let(nil, ::T.untyped) - SCOPE_TYPES = ::T.let(nil, ::T.untyped) - SEND_TYPE = ::T.let(nil, ::T.untyped) - TWISTED_SCOPE_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) - VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) - VARIABLE_REFERENCE_TYPE = ::T.let(nil, ::T.untyped) - ZERO_ARITY_SUPER_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Assignment - MULTIPLE_LEFT_HAND_SIDE_TYPE = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::VariableForce::Branch - CLASSES_BY_TYPE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Reference - VARIABLE_REFERENCE_TYPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Scope - OUTER_SCOPE_CHILD_INDICES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::VariableForce::Variable - VARIABLE_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Cop::VisibilityHelp - VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::DirectiveComment - COPS_PATTERN = ::T.let(nil, ::T.untyped) - COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped) - COP_NAME_PATTERN = ::T.let(nil, ::T.untyped) - DIRECTIVE_COMMENT_REGEXP = ::T.let(nil, ::T.untyped) - REDUNDANT_DIRECTIVE_COP = ::T.let(nil, ::T.untyped) - REDUNDANT_DIRECTIVE_COP_DEPARTMENT = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Ext::Range - def single_line?(); end -end - -module RuboCop::Ext::Range -end - -class RuboCop::FeatureLoader - def initialize(config_directory_path:, feature:); end - - def load(); end -end - -class RuboCop::FeatureLoader - def self.load(config_directory_path:, feature:); end -end - -class RuboCop::Formatter::ClangStyleFormatter - ELLIPSES = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::DisabledConfigFormatter - HEADING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::FormatterSet - BUILTIN_FORMATTERS_FOR_KEYS = ::T.let(nil, ::T.untyped) - FORMATTER_APIS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::FuubarStyleFormatter - RESET_SEQUENCE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::GitHubActionsFormatter - ESCAPE_MAP = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::HTMLFormatter - ELLIPSES = ::T.let(nil, ::T.untyped) - TEMPLATE_PATH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::HTMLFormatter::ERBContext - LOGO_IMAGE_PATH = ::T.let(nil, ::T.untyped) - SEVERITY_COLORS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::PacmanFormatter - FALLBACK_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) - GHOST = ::T.let(nil, ::T.untyped) - PACDOT = ::T.let(nil, ::T.untyped) - PACMAN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::ProgressFormatter - DOT = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Formatter::SimpleTextFormatter - COLOR_FOR_SEVERITY = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment - KEYWORDS = ::T.let(nil, ::T.untyped) - TOKEN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment::EmacsComment - FORMAT = ::T.let(nil, ::T.untyped) - OPERATOR = ::T.let(nil, ::T.untyped) - REGEXP = ::T.let(nil, ::T.untyped) - SEPARATOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::MagicComment::VimComment - FORMAT = ::T.let(nil, ::T.untyped) - KEYWORDS = ::T.let(nil, ::T.untyped) - OPERATOR = ::T.let(nil, ::T.untyped) - REGEXP = ::T.let(nil, ::T.untyped) - SEPARATOR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::AST::NodePattern -end - -RuboCop::NodePattern::Builder = RuboCop::AST::NodePattern::Builder - -class RuboCop::AST::NodePattern::Compiler -end - -RuboCop::NodePattern::Compiler::Debug = RuboCop::AST::NodePattern::Compiler::Debug - -class RuboCop::AST::NodePattern::Compiler -end - -class RuboCop::AST::NodePattern::Lexer -end - -RuboCop::NodePattern::Lexer::Error = RuboCop::AST::NodePattern::LexerRex::ScanError - -class RuboCop::AST::NodePattern::Lexer -end - -class RuboCop::AST::NodePattern -end - -class RuboCop::Options - DEFAULT_MAXIMUM_EXCLUSION_ITEMS = ::T.let(nil, ::T.untyped) - EXITING_OPTIONS = ::T.let(nil, ::T.untyped) - E_STDIN_NO_PATH = ::T.let(nil, ::T.untyped) -end - -module RuboCop::OptionsHelp - FORMATTER_OPTION_LIST = ::T.let(nil, ::T.untyped) - MAX_EXCL = ::T.let(nil, ::T.untyped) - TEXT = ::T.let(nil, ::T.untyped) -end - -RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource - -module RuboCop::RSpec::Version - STRING = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Rake - CONFIG = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::RemoteConfig - CACHE_LIFETIME = ::T.let(nil, ::T.untyped) -end - -class RuboCop::ResultCache - DL_EXTENSIONS = ::T.let(nil, ::T.untyped) - NON_CHANGING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Runner - MAX_ITERATIONS = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Sorbet - CONFIG = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetFinder - HIDDEN_PATH_SUBSTRING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby - DEFAULT_VERSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby::GemspecFile - GEMSPEC_EXTENSION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby::RubyVersionFile - RUBY_VERSION_FILENAME = ::T.let(nil, ::T.untyped) - RUBY_VERSION_PATTERN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::TargetRuby::ToolVersionsFile - TOOL_VERSIONS_FILENAME = ::T.let(nil, ::T.untyped) - TOOL_VERSIONS_PATTERN = ::T.let(nil, ::T.untyped) -end - -RuboCop::Token = RuboCop::AST::Token - -module RuboCop::Version - CANONICAL_FEATURE_NAMES = ::T.let(nil, ::T.untyped) - EXTENSION_PATH_NAMES = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - STRING = ::T.let(nil, ::T.untyped) -end - -class RubyLex - def check_code_block(code); end - - def check_corresponding_token_depth(); end - - def check_newline_depth_difference(); end - - def check_state(code); end - - def check_string_literal(); end - - def each_top_level_statement(); end - - def initialize_input(); end - - def lex(); end - - def process_continue(); end - - def process_literal_type(); end - - def process_nesting_level(); end - - def prompt(); end - - def ripper_lex_without_warning(code); end - - def set_auto_indent(context); end - - def set_input(io, p=T.unsafe(nil), &block); end - - def set_prompt(p=T.unsafe(nil), &block); end -end - -class RubyLex::TerminateLineInput - def initialize(); end -end - -class RubyLex::TerminateLineInput -end - -class RubyLex - def self.compile_with_errors_suppressed(code); end -end - -class RubyVM::AbstractSyntaxTree::Node - def pretty_print_children(q, names=T.unsafe(nil)); end -end - -module RubyVM::MJIT -end - -module RubyVM::MJIT - def self.enabled?(); end - - def self.pause(*arg); end - - def self.resume(); end -end - -ScanError = StringScanner::Error - -class Set - def ==(other); end - - def ===(o); end - - def divide(&func); end - - def eql?(o); end - - def flatten_merge(set, seen=T.unsafe(nil)); end - - def pretty_print(pp); end - - def pretty_print_cycle(pp); end - - def reset(); end - InspectKey = ::T.let(nil, ::T.untyped) -end - -module SimpleCov - VERSION = ::T.let(nil, ::T.untyped) -end - -module SimpleCov::Configuration - DEFAULT_COVERAGE_CRITERION = ::T.let(nil, ::T.untyped) - SUPPORTED_COVERAGE_CRITERIA = ::T.let(nil, ::T.untyped) -end - -module SimpleCov::ExitCodes - EXCEPTION = ::T.let(nil, ::T.untyped) - MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped) - MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped) - SUCCESS = ::T.let(nil, ::T.untyped) -end - -class SimpleCov::ExitCodes::MaximumCoverageDropCheck - MAX_DROP_ACCURACY = ::T.let(nil, ::T.untyped) -end - -class SimpleCov::Formatter::HTMLFormatter - VERSION = ::T.let(nil, ::T.untyped) -end - -class SimpleCov::LinesClassifier - COMMENT_LINE = ::T.let(nil, ::T.untyped) - NOT_RELEVANT = ::T.let(nil, ::T.untyped) - RELEVANT = ::T.let(nil, ::T.untyped) - WHITESPACE_LINE = ::T.let(nil, ::T.untyped) - WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped) -end - -class SimpleCov::SourceFile - RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = ::T.let(nil, ::T.untyped) - SHEBANG_REGEX = ::T.let(nil, ::T.untyped) -end - -class SimpleCovJSONFormatter::ResultExporter - FILENAME = ::T.let(nil, ::T.untyped) -end - -class SimpleDelegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -module Singleton - def _dump(depth=T.unsafe(nil)); end - - def clone(); end - - def dup(); end -end - -module Singleton::SingletonClassMethods - def _load(str); end - - def clone(); end -end - -module Singleton - def self.__init__(klass); end -end - -class Socket - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -module Socket::Constants - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -class String - include ::JSON::Ext::Generator::GeneratorMethods::String - def shellescape(); end - - def shellsplit(); end -end - -class String - extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend -end - -class StringIO - def set_encoding_by_bom(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class StringScanner - def bol?(); end - - def fixed_anchor?(); end - - def initialize(*arg); end - Id = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Struct - def deconstruct(); end - - def deconstruct_keys(arg); end - - def filter(*arg); end -end - -Struct::Group = Etc::Group - -Struct::Passwd = Etc::Passwd - -Struct::Tms = Process::Tms - -class Tempfile - def _close(); end - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Tempfile::Remover - def call(*args); end - - def initialize(tmpfile); end -end - -class Tempfile::Remover -end - -class Thor - HELP_MAPPINGS = ::T.let(nil, ::T.untyped) - TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped) - THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module Thor::Actions - WARNINGS = ::T.let(nil, ::T.untyped) -end - -Thor::AmbiguousTaskError = Thor::AmbiguousCommandError - -class Thor::Argument - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Thor::Arguments - NUMERIC = ::T.let(nil, ::T.untyped) -end - -class Thor::Command - FILE_REGEXP = ::T.let(nil, ::T.untyped) -end - -Thor::Correctable = DidYouMean::Correctable - -Thor::DynamicTask = Thor::DynamicCommand - -Thor::HiddenTask = Thor::HiddenCommand - -class Thor::Option - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Thor::Options - EQ_RE = ::T.let(nil, ::T.untyped) - LONG_RE = ::T.let(nil, ::T.untyped) - OPTS_END = ::T.let(nil, ::T.untyped) - SHORT_NUM = ::T.let(nil, ::T.untyped) - SHORT_RE = ::T.let(nil, ::T.untyped) - SHORT_SQ_RE = ::T.let(nil, ::T.untyped) -end - -module Thor::RakeCompat - include ::Rake::DSL - include ::Rake::FileUtilsExt - include ::FileUtils - include ::FileUtils::StreamUtils_ -end - -module Thor::RakeCompat - def self.included(base); end - - def self.rake_classes(); end -end - -module Thor::Shell - SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Basic - def answer_match(possibilities, answer, case_insensitive); end - - def as_unicode(); end - - def ask(statement, *args); end - - def ask_filtered(statement, color, options); end - - def ask_simply(statement, color, options); end - - def base(); end - - def base=(base); end - - def can_display_colors?(); end - - def dynamic_width(); end - - def dynamic_width_stty(); end - - def dynamic_width_tput(); end - - def error(statement); end - - def file_collision(destination); end - - def file_collision_help(); end - - def git_merge_tool(); end - - def indent(count=T.unsafe(nil)); end - - def is?(value); end - - def lookup_color(color); end - - def merge(destination, content); end - - def merge_tool(); end - - def mute(); end - - def mute?(); end - - def no?(statement, color=T.unsafe(nil)); end - - def padding(); end - - def padding=(value); end - - def prepare_message(message, *color); end - - def print_in_columns(array); end - - def print_table(array, options=T.unsafe(nil)); end - - def print_wrapped(message, options=T.unsafe(nil)); end - - def quiet?(); end - - def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_error(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_status(status, message, log_status=T.unsafe(nil)); end - - def set_color(string, *arg); end - - def show_diff(destination, content); end - - def stderr(); end - - def stdout(); end - - def terminal_width(); end - - def truncate(string, width); end - - def unix?(); end - - def yes?(statement, color=T.unsafe(nil)); end - DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Basic -end - -class Thor::Shell::Color - def are_colors_disabled?(); end - - def are_colors_supported?(); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::Color -end - -class Thor::Shell::HTML - def ask(statement, color=T.unsafe(nil)); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Thor::Shell::HTML -end - -Thor::Task = Thor::Command - -class Thor::UndefinedCommandError - include ::DidYouMean::Correctable -end - -Thor::UndefinedTaskError = Thor::UndefinedCommandError - -class Thor::UnknownArgumentError - include ::DidYouMean::Correctable -end - -class TracePoint - def eval_script(); end - - def instruction_sequence(); end - - def parameters(); end -end - -class TracePoint - def self.new(*events); end -end - -class TrueClass - include ::JSON::Ext::Generator::GeneratorMethods::TrueClass -end - -module URI - include ::URI::RFC2396_REGEXP -end - -class URI::FTP - def buffer_open(buf, proxy, options); end -end - -class URI::FTP - def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end -end - -class URI::File - def check_password(user); end - - def check_user(user); end - - def check_userinfo(user); end - - def set_userinfo(v); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class URI::File -end - -class URI::HTTP - def buffer_open(buf, proxy, options); end -end - -class URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end -end - -class URI::MailTo - def initialize(*arg); end -end - -URI::Parser = URI::RFC2396_Parser - -URI::REGEXP = URI::RFC2396_REGEXP - -class URI::RFC2396_Parser - def initialize(opts=T.unsafe(nil)); end -end - -class URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -module URI::Util - def self.make_components_hash(klass, array_hash); end -end - -module URI - extend ::URI::Escape - def self.get_encoding(label); end - - def self.open(name, *rest, &block); end -end - -class Unicode::DisplayWidth - DATA_DIRECTORY = ::T.let(nil, ::T.untyped) - DEPTHS = ::T.let(nil, ::T.untyped) - INDEX = ::T.let(nil, ::T.untyped) - INDEX_FILENAME = ::T.let(nil, ::T.untyped) - UNICODE_VERSION = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module UnicodeNormalize -end - -module UnicodeNormalize -end - -module Warning - extend ::Warning -end - -module YARD - CONFIG_DIR = ::T.let(nil, ::T.untyped) - ROOT = ::T.let(nil, ::T.untyped) - TEMPLATE_ROOT = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class YARD::CLI::CommandParser - def run(*args); end -end - -class YARD::CLI::CommandParser - def self.commands(); end - - def self.commands=(commands); end - - def self.default_command(); end - - def self.default_command=(default_command); end - - def self.run(*args); end -end - -class YARD::CLI::Config - def append(); end - - def append=(append); end - - def as_list(); end - - def as_list=(as_list); end - - def gem_install_cmd(); end - - def gem_install_cmd=(gem_install_cmd); end - - def key(); end - - def key=(key); end - - def reset(); end - - def reset=(reset); end - - def run(*args); end - - def values(); end - - def values=(values); end -end - -class YARD::CLI::Config -end - -class YARD::CLI::Diff - def run(*args); end -end - -class YARD::CLI::Diff -end - -class YARD::CLI::Display - def format_objects(); end - - def initialize(*args); end - - def wrap_layout(contents); end -end - -class YARD::CLI::Display -end - -class YARD::CLI::Gems - def run(*args); end -end - -class YARD::CLI::Gems -end - -class YARD::CLI::Graph - def objects(); end - - def options(); end - - def run(*args); end -end - -class YARD::CLI::Graph -end - -class YARD::CLI::Help - def run(*args); end -end - -class YARD::CLI::Help -end - -class YARD::CLI::I18n -end - -class YARD::CLI::I18n -end - -class YARD::CLI::List - def run(*args); end -end - -class YARD::CLI::List -end - -class YARD::CLI::MarkupTypes - def run(*args); end -end - -class YARD::CLI::MarkupTypes -end - -class YARD::CLI::Server - def adapter(); end - - def adapter=(adapter); end - - def libraries(); end - - def libraries=(libraries); end - - def options(); end - - def options=(options); end - - def run(*args); end - - def scripts(); end - - def scripts=(scripts); end - - def server_options(); end - - def server_options=(server_options); end - - def template_paths(); end - - def template_paths=(template_paths); end -end - -class YARD::CLI::Server -end - -class YARD::CLI::Stats - include ::YARD::Templates::Helpers::BaseHelper - def initialize(parse=T.unsafe(nil)); end - - def output(name, data, undoc=T.unsafe(nil)); end - - def parse(); end - - def parse=(parse); end - - def print_statistics(); end - - def print_undocumented_objects(); end - - def stats_for_attributes(); end - - def stats_for_classes(); end - - def stats_for_constants(); end - - def stats_for_files(); end - - def stats_for_methods(); end - - def stats_for_modules(); end - STATS_ORDER = ::T.let(nil, ::T.untyped) -end - -class YARD::CLI::Stats -end - -class YARD::CLI::YRI - def cache_object(name, path); end - - def find_object(name); end - - def print_object(object); end - - def print_usage(); end - - def run(*args); end - CACHE_FILE = ::T.let(nil, ::T.untyped) - DEFAULT_SEARCH_PATHS = ::T.let(nil, ::T.untyped) - SEARCH_PATHS_FILE = ::T.let(nil, ::T.untyped) -end - -class YARD::CLI::YRI -end - -class YARD::CLI::YardoptsCommand - DEFAULT_YARDOPTS_FILE = ::T.let(nil, ::T.untyped) -end - -module YARD::CodeObjects - BUILTIN_ALL = ::T.let(nil, ::T.untyped) - BUILTIN_CLASSES = ::T.let(nil, ::T.untyped) - BUILTIN_EXCEPTIONS = ::T.let(nil, ::T.untyped) - BUILTIN_EXCEPTIONS_HASH = ::T.let(nil, ::T.untyped) - BUILTIN_MODULES = ::T.let(nil, ::T.untyped) - CONSTANTMATCH = ::T.let(nil, ::T.untyped) - CONSTANTSTART = ::T.let(nil, ::T.untyped) - CSEP = ::T.let(nil, ::T.untyped) - CSEPQ = ::T.let(nil, ::T.untyped) - ISEP = ::T.let(nil, ::T.untyped) - ISEPQ = ::T.let(nil, ::T.untyped) - METHODMATCH = ::T.let(nil, ::T.untyped) - METHODNAMEMATCH = ::T.let(nil, ::T.untyped) - NAMESPACEMATCH = ::T.let(nil, ::T.untyped) - NSEP = ::T.let(nil, ::T.untyped) - NSEPQ = ::T.let(nil, ::T.untyped) - PROXY_MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Config - CONFIG_DIR = ::T.let(nil, ::T.untyped) - CONFIG_FILE = ::T.let(nil, ::T.untyped) - DEFAULT_CONFIG_OPTIONS = ::T.let(nil, ::T.untyped) - IGNORED_PLUGINS = ::T.let(nil, ::T.untyped) - YARD_PLUGIN_PREFIX = ::T.let(nil, ::T.untyped) -end - -class YARD::Docstring - META_MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::DocstringParser - META_MATCH = ::T.let(nil, ::T.untyped) -end - -module YARD::GemIndex -end - -module YARD::GemIndex - def self.all(); end - - def self.each(&block); end - - def self.find_all_by_name(*args); end -end - -class YARD::Handlers::C::AliasHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::AliasHandler -end - -class YARD::Handlers::C::AttributeHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::AttributeHandler -end - -class YARD::Handlers::C::Base - include ::YARD::Handlers::C::HandlerMethods - include ::YARD::Parser::C - include ::YARD::Handlers::Common::MethodHandler - def ensure_variable_defined!(var, max_retries=T.unsafe(nil)); end - - def namespace_for_variable(var); end - - def namespaces(); end - - def override_comments(); end - - def parse_block(opts=T.unsafe(nil)); end - - def process_file(file, object); end - - def processed_files(); end - - def symbols(); end - ERROR_CLASS_NAMES = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::Base - def self.handles?(statement, processor); end - - def self.statement_class(type=T.unsafe(nil)); end -end - -class YARD::Handlers::C::ClassHandler - MATCH1 = ::T.let(nil, ::T.untyped) - MATCH2 = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::ClassHandler -end - -class YARD::Handlers::C::ConstantHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::ConstantHandler -end - -module YARD::Handlers::C::HandlerMethods - include ::YARD::Parser::C - include ::YARD::CodeObjects - include ::YARD::Handlers::Common::MethodHandler - def handle_alias(var_name, new_name, old_name); end - - def handle_attribute(var_name, name, read, write); end - - def handle_class(var_name, class_name, parent, in_module=T.unsafe(nil)); end - - def handle_constants(type, var_name, const_name, value); end - - def handle_method(scope, var_name, name, func_name, _source_file=T.unsafe(nil)); end - - def handle_module(var_name, module_name, in_module=T.unsafe(nil)); end -end - -module YARD::Handlers::C::HandlerMethods -end - -class YARD::Handlers::C::InitHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::InitHandler -end - -class YARD::Handlers::C::MethodHandler - MATCH1 = ::T.let(nil, ::T.untyped) - MATCH2 = ::T.let(nil, ::T.untyped) - MATCH3 = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::MethodHandler -end - -class YARD::Handlers::C::MixinHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::MixinHandler -end - -class YARD::Handlers::C::ModuleHandler - MATCH1 = ::T.let(nil, ::T.untyped) - MATCH2 = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::ModuleHandler -end - -class YARD::Handlers::C::OverrideCommentHandler -end - -class YARD::Handlers::C::OverrideCommentHandler -end - -class YARD::Handlers::C::PathHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::PathHandler -end - -class YARD::Handlers::C::StructHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::StructHandler -end - -class YARD::Handlers::C::SymbolHandler - MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::C::SymbolHandler -end - -module YARD::Handlers::Common::MethodHandler - def add_predicate_return_tag(obj); end -end - -module YARD::Handlers::Common::MethodHandler -end - -class YARD::Handlers::Processor - def extra_state(); end - - def extra_state=(extra_state); end - - def file(); end - - def file=(file); end - - def find_handlers(statement); end - - def globals(); end - - def globals=(globals); end - - def initialize(parser); end - - def namespace(); end - - def namespace=(namespace); end - - def owner(); end - - def owner=(owner); end - - def parse_remaining_files(); end - - def parser_type(); end - - def parser_type=(parser_type); end - - def process(statements); end - - def scope(); end - - def scope=(scope); end - - def visibility(); end - - def visibility=(visibility); end -end - -class YARD::Handlers::Processor - def self.namespace_for_handler(); end - - def self.register_handler_namespace(type, ns); end -end - -class YARD::Handlers::Ruby::AliasHandler -end - -class YARD::Handlers::Ruby::AliasHandler -end - -class YARD::Handlers::Ruby::AttributeHandler - def validated_attribute_names(params); end -end - -class YARD::Handlers::Ruby::Base - extend ::YARD::Parser::Ruby -end - -class YARD::Handlers::Ruby::ClassConditionHandler - def parse_condition(); end - - def parse_else_block(); end - - def parse_then_block(); end -end - -class YARD::Handlers::Ruby::ClassConditionHandler -end - -class YARD::Handlers::Ruby::ClassHandler - include ::YARDSorbet::Handlers::StructClassHandler -end - -class YARD::Handlers::Ruby::ClassVariableHandler -end - -class YARD::Handlers::Ruby::ClassVariableHandler -end - -class YARD::Handlers::Ruby::CommentHandler -end - -class YARD::Handlers::Ruby::CommentHandler -end - -class YARD::Handlers::Ruby::ConstantHandler - include ::YARD::Handlers::Ruby::StructHandlerMethods -end - -class YARD::Handlers::Ruby::ConstantHandler -end - -class YARD::Handlers::Ruby::DSLHandler - include ::YARD::Handlers::Ruby::DSLHandlerMethods -end - -class YARD::Handlers::Ruby::DSLHandler -end - -module YARD::Handlers::Ruby::DSLHandlerMethods - include ::YARD::CodeObjects - include ::YARD::Parser - def handle_comments(); end - - def register_docstring(object, docstring=T.unsafe(nil), stmt=T.unsafe(nil)); end - IGNORE_METHODS = ::T.let(nil, ::T.untyped) -end - -module YARD::Handlers::Ruby::DSLHandlerMethods -end - -module YARD::Handlers::Ruby::DecoratorHandlerMethods - def process_decorator(*nodes, &block); end -end - -module YARD::Handlers::Ruby::DecoratorHandlerMethods -end - -class YARD::Handlers::Ruby::ExceptionHandler -end - -class YARD::Handlers::Ruby::ExceptionHandler -end - -class YARD::Handlers::Ruby::ExtendHandler -end - -class YARD::Handlers::Ruby::ExtendHandler -end - -class YARD::Handlers::Ruby::Legacy::AliasHandler -end - -class YARD::Handlers::Ruby::Legacy::AliasHandler -end - -class YARD::Handlers::Ruby::Legacy::AttributeHandler -end - -class YARD::Handlers::Ruby::Legacy::AttributeHandler -end - -class YARD::Handlers::Ruby::Legacy::Base - include ::YARD::Parser::Ruby::Legacy::RubyToken - def parse_block(opts=T.unsafe(nil)); end -end - -class YARD::Handlers::Ruby::Legacy::Base - def self.handles?(stmt); end -end - -class YARD::Handlers::Ruby::Legacy::ClassConditionHandler - def parse_condition(); end - - def parse_else_block(); end - - def parse_then_block(); end -end - -class YARD::Handlers::Ruby::Legacy::ClassConditionHandler -end - -class YARD::Handlers::Ruby::Legacy::ClassHandler - include ::YARD::Handlers::Ruby::StructHandlerMethods -end - -class YARD::Handlers::Ruby::Legacy::ClassHandler -end - -class YARD::Handlers::Ruby::Legacy::ClassVariableHandler - HANDLER_MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::Ruby::Legacy::ClassVariableHandler -end - -class YARD::Handlers::Ruby::Legacy::CommentHandler -end - -class YARD::Handlers::Ruby::Legacy::CommentHandler -end - -class YARD::Handlers::Ruby::Legacy::ConstantHandler - include ::YARD::Handlers::Ruby::StructHandlerMethods - HANDLER_MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Handlers::Ruby::Legacy::ConstantHandler -end - -class YARD::Handlers::Ruby::Legacy::DSLHandler - include ::YARD::Handlers::Ruby::DSLHandlerMethods -end - -class YARD::Handlers::Ruby::Legacy::DSLHandler -end - -class YARD::Handlers::Ruby::Legacy::ExceptionHandler -end - -class YARD::Handlers::Ruby::Legacy::ExceptionHandler -end - -class YARD::Handlers::Ruby::Legacy::ExtendHandler -end - -class YARD::Handlers::Ruby::Legacy::ExtendHandler -end - -class YARD::Handlers::Ruby::Legacy::MethodHandler -end - -class YARD::Handlers::Ruby::Legacy::MethodHandler -end - -class YARD::Handlers::Ruby::Legacy::MixinHandler -end - -class YARD::Handlers::Ruby::Legacy::MixinHandler -end - -class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler -end - -class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler -end - -class YARD::Handlers::Ruby::Legacy::ModuleHandler -end - -class YARD::Handlers::Ruby::Legacy::ModuleHandler -end - -class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler -end - -class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler -end - -class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler -end - -class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler -end - -class YARD::Handlers::Ruby::Legacy::VisibilityHandler -end - -class YARD::Handlers::Ruby::Legacy::VisibilityHandler -end - -class YARD::Handlers::Ruby::Legacy::YieldHandler -end - -class YARD::Handlers::Ruby::Legacy::YieldHandler -end - -class YARD::Handlers::Ruby::MethodConditionHandler -end - -class YARD::Handlers::Ruby::MethodConditionHandler -end - -class YARD::Handlers::Ruby::MethodHandler - include ::YARD::Handlers::Common::MethodHandler - def format_args(); end -end - -class YARD::Handlers::Ruby::MixinHandler - include ::IgnoreMonkeyPatchMixins -end - -class YARD::Handlers::Ruby::ModuleFunctionHandler - include ::YARD::Handlers::Ruby::DecoratorHandlerMethods - def make_module_function(instance_method, namespace); end -end - -class YARD::Handlers::Ruby::ModuleFunctionHandler -end - -class YARD::Handlers::Ruby::ModuleHandler -end - -class YARD::Handlers::Ruby::ModuleHandler -end - -class YARD::Handlers::Ruby::PrivateClassMethodHandler - include ::YARD::Handlers::Ruby::DecoratorHandlerMethods -end - -class YARD::Handlers::Ruby::PrivateClassMethodHandler -end - -class YARD::Handlers::Ruby::PrivateConstantHandler -end - -class YARD::Handlers::Ruby::PrivateConstantHandler -end - -class YARD::Handlers::Ruby::PublicClassMethodHandler - include ::YARD::Handlers::Ruby::DecoratorHandlerMethods -end - -class YARD::Handlers::Ruby::PublicClassMethodHandler -end - -class YARD::Handlers::Ruby::VisibilityHandler - include ::YARD::Handlers::Ruby::DecoratorHandlerMethods -end - -class YARD::Handlers::Ruby::VisibilityHandler -end - -class YARD::Handlers::Ruby::YieldHandler -end - -class YARD::Handlers::Ruby::YieldHandler -end - -class YARD::I18n::Locale - def initialize(name); end - - def load(locale_directory); end - - def name(); end - - def translate(message); end -end - -class YARD::I18n::Locale - def self.default(); end - - def self.default=(locale); end -end - -class YARD::I18n::Message - def ==(other); end - - def add_comment(comment); end - - def add_location(path, line); end - - def comments(); end - - def id(); end - - def initialize(id); end - - def locations(); end -end - -class YARD::I18n::Message -end - -class YARD::I18n::Messages - include ::Enumerable - def ==(other); end - - def [](id); end - - def each(&block); end - - def messages(); end - - def register(id); end -end - -class YARD::I18n::Messages -end - -class YARD::I18n::PotGenerator - def generate(); end - - def initialize(relative_base_path); end - - def messages(); end - - def parse_files(files); end - - def parse_objects(objects); end -end - -class YARD::I18n::PotGenerator -end - -class YARD::I18n::Text - def extract_messages(); end - - def initialize(input, options=T.unsafe(nil)); end - - def translate(locale); end -end - -class YARD::I18n::Text -end - -class YARD::Logger - PROGRESS_INDICATORS = ::T.let(nil, ::T.untyped) -end - -module YARD::Parser::Ruby::Legacy::RubyToken - def Token(token, value=T.unsafe(nil)); end - - def set_token_position(line, char); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - NEWLINE_TOKEN = ::T.let(nil, ::T.untyped) - TkReading2Token = ::T.let(nil, ::T.untyped) - TkSymbol2Token = ::T.let(nil, ::T.untyped) - TokenDefinitions = ::T.let(nil, ::T.untyped) -end - -module YARD::Parser::Ruby::Legacy::RubyToken - def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); end -end - -class YARD::Rake::YardocTask - def after(); end - - def after=(after); end - - def before(); end - - def before=(before); end - - def define(); end - - def files(); end - - def files=(files); end - - def initialize(name=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def options(); end - - def options=(options); end - - def stats_options(); end - - def stats_options=(stats_options); end - - def verifier(); end - - def verifier=(verifier); end -end - -class YARD::Rake::YardocTask -end - -module YARD::Registry - DEFAULT_PO_DIR = ::T.let(nil, ::T.untyped) - DEFAULT_YARDOC_FILE = ::T.let(nil, ::T.untyped) - LOCAL_YARDOC_INDEX = ::T.let(nil, ::T.untyped) -end - -class YARD::RegistryResolver - include ::YARD::CodeObjects::NamespaceMapper - def initialize(registry=T.unsafe(nil)); end - - def lookup_by_path(path, opts=T.unsafe(nil)); end -end - -class YARD::RegistryResolver -end - -class YARD::RegistryStore - def [](key); end - - def []=(key, value); end - - def checksums(); end - - def checksums_path(); end - - def delete(key); end - - def destroy(force=T.unsafe(nil)); end - - def file(); end - - def get(key); end - - def keys(reload=T.unsafe(nil)); end - - def load(file=T.unsafe(nil)); end - - def load!(file=T.unsafe(nil)); end - - def load_all(); end - - def load_yardoc(); end - - def locale(name); end - - def lock_for_writing(file=T.unsafe(nil), &block); end - - def locked_for_writing?(file=T.unsafe(nil)); end - - def object_types_path(); end - - def objects_path(); end - - def paths_for_type(type, reload=T.unsafe(nil)); end - - def proxy_types(); end - - def proxy_types_path(); end - - def put(key, value); end - - def root(); end - - def save(merge=T.unsafe(nil), file=T.unsafe(nil)); end - - def values(reload=T.unsafe(nil)); end - - def values_for_type(type, reload=T.unsafe(nil)); end -end - -class YARD::RegistryStore -end - -class YARD::Serializers::Base - def after_serialize(data); end - - def before_serialize(); end - - def exists?(object); end - - def initialize(opts=T.unsafe(nil)); end - - def options(); end - - def serialize(object, data); end - - def serialized_path(object); end -end - -class YARD::Serializers::Base -end - -class YARD::Serializers::FileSystemSerializer - def basepath(); end - - def basepath=(value); end - - def extension(); end - - def extension=(value); end -end - -class YARD::Serializers::FileSystemSerializer -end - -class YARD::Serializers::ProcessSerializer - def initialize(cmd); end - - def serialize(_object, data); end -end - -class YARD::Serializers::ProcessSerializer -end - -class YARD::Serializers::StdoutSerializer - def initialize(wrap=T.unsafe(nil)); end - - def serialize(_object, data); end -end - -class YARD::Serializers::StdoutSerializer -end - -class YARD::Serializers::YardocSerializer - def checksums_path(); end - - def complete?(); end - - def complete_lock_path(); end - - def deserialize(path, is_path=T.unsafe(nil)); end - - def initialize(yfile); end - - def lock_for_writing(); end - - def locked_for_writing?(); end - - def object_types_path(); end - - def objects_path(); end - - def processing_path(); end - - def proxy_types_path(); end - - def serialize(object); end -end - -class YARD::Serializers::YardocSerializer -end - -class YARD::Server::Adapter - def add_library(library); end - - def document_root(); end - - def document_root=(document_root); end - - def initialize(libs, opts=T.unsafe(nil), server_opts=T.unsafe(nil)); end - - def libraries(); end - - def libraries=(libraries); end - - def options(); end - - def options=(options); end - - def router(); end - - def router=(router); end - - def server_options(); end - - def server_options=(server_options); end - - def start(); end -end - -class YARD::Server::Adapter - def self.setup(); end - - def self.shutdown(); end -end - -class YARD::Server::Commands::Base - def adapter(); end - - def adapter=(adapter); end - - def body(); end - - def body=(body); end - - def cache(data); end - - def caching(); end - - def caching=(caching); end - - def call(request); end - - def command_options(); end - - def command_options=(command_options); end - - def headers(); end - - def headers=(headers); end - - def initialize(opts=T.unsafe(nil)); end - - def not_found(); end - - def path(); end - - def path=(path); end - - def redirect(url); end - - def render(object=T.unsafe(nil)); end - - def request(); end - - def request=(request); end - - def run(); end - - def status(); end - - def status=(status); end -end - -class YARD::Server::Commands::Base -end - -class YARD::Server::Commands::DisplayFileCommand - def index(); end - - def index=(index); end -end - -class YARD::Server::Commands::DisplayFileCommand -end - -class YARD::Server::Commands::DisplayObjectCommand - include ::YARD::Server::DocServerHelper - def index(); end -end - -class YARD::Server::Commands::DisplayObjectCommand -end - -class YARD::Server::Commands::FramesCommand -end - -class YARD::Server::Commands::FramesCommand -end - -class YARD::Server::Commands::LibraryCommand - def incremental(); end - - def incremental=(incremental); end - - def library(); end - - def library=(library); end - - def options(); end - - def options=(options); end - - def serializer(); end - - def serializer=(serializer); end - - def single_library(); end - - def single_library=(single_library); end - - def use_fork(); end - - def use_fork=(use_fork); end - CAN_FORK = ::T.let(nil, ::T.untyped) -end - -class YARD::Server::Commands::LibraryCommand -end - -class YARD::Server::Commands::LibraryIndexCommand - def options(); end - - def options=(options); end -end - -class YARD::Server::Commands::LibraryIndexCommand -end - -class YARD::Server::Commands::ListCommand - include ::YARD::Templates::Helpers::BaseHelper -end - -class YARD::Server::Commands::ListCommand -end - -class YARD::Server::Commands::RootRequestCommand - include ::YARD::Server::Commands::StaticFileHelpers - include ::WEBrick::HTTPUtils -end - -class YARD::Server::Commands::RootRequestCommand -end - -class YARD::Server::Commands::SearchCommand - include ::YARD::Templates::Helpers::BaseHelper - include ::YARD::Templates::Helpers::ModuleHelper - include ::YARD::Server::DocServerHelper - def query(); end - - def query=(query); end - - def results(); end - - def results=(results); end - - def visible_results(); end -end - -class YARD::Server::Commands::SearchCommand -end - -class YARD::Server::Commands::StaticFileCommand - include ::YARD::Server::Commands::StaticFileHelpers - include ::WEBrick::HTTPUtils - STATIC_PATHS = ::T.let(nil, ::T.untyped) -end - -class YARD::Server::Commands::StaticFileCommand -end - -module YARD::Server::Commands::StaticFileHelpers - include ::WEBrick::HTTPUtils - def favicon?(); end - - def static_template_file?(); end -end - -module YARD::Server::Commands::StaticFileHelpers - def self.find_file(adapter, url); end -end - -module YARD::Server::DocServerHelper - def abs_url(*path_components); end - - def base_path(path); end - - def mtime(file); end - - def mtime_url(file); end - - def router(); end - - def url_for(obj, anchor=T.unsafe(nil), relative=T.unsafe(nil)); end - - def url_for_file(filename, anchor=T.unsafe(nil)); end - - def url_for_frameset(); end - - def url_for_index(); end - - def url_for_list(type); end - - def url_for_main(); end -end - -module YARD::Server::DocServerHelper -end - -class YARD::Server::DocServerSerializer - def initialize(_command=T.unsafe(nil)); end -end - -class YARD::Server::DocServerSerializer -end - -class YARD::Server::FinishRequest -end - -class YARD::Server::FinishRequest -end - -class YARD::Server::LibraryVersion - def ==(other); end - - def eql?(other); end - - def equal?(other); end - - def gemspec(); end - - def initialize(name, version=T.unsafe(nil), yardoc=T.unsafe(nil), source=T.unsafe(nil)); end - - def load_yardoc_from_disk(); end - - def load_yardoc_from_gem(); end - - def name(); end - - def name=(name); end - - def prepare!(); end - - def ready?(); end - - def source(); end - - def source=(source); end - - def source_path(); end - - def source_path=(source_path); end - - def source_path_for_disk(); end - - def source_path_for_gem(); end - - def to_s(url_format=T.unsafe(nil)); end - - def version(); end - - def version=(version); end - - def yardoc_file(); end - - def yardoc_file=(yardoc_file); end - - def yardoc_file_for_gem(); end -end - -class YARD::Server::LibraryVersion -end - -class YARD::Server::NotFoundError -end - -class YARD::Server::NotFoundError -end - -class YARD::Server::Router - include ::YARD::Server::StaticCaching - include ::YARD::Server::Commands - def adapter(); end - - def adapter=(adapter); end - - def call(request); end - - def docs_prefix(); end - - def final_options(library, paths); end - - def initialize(adapter); end - - def list_prefix(); end - - def parse_library_from_path(paths); end - - def request(); end - - def request=(request); end - - def route(path=T.unsafe(nil)); end - - def route_docs(library, paths); end - - def route_index(); end - - def route_list(library, paths); end - - def route_search(library, paths); end - - def route_static(library, paths); end - - def search_prefix(); end - - def static_prefix(); end -end - -class YARD::Server::Router -end - -module YARD::Server::StaticCaching - def check_static_cache(); end -end - -module YARD::Server::StaticCaching -end - -class YARD::Server::WebrickAdapter -end - -class YARD::Server::WebrickAdapter -end - -class YARD::Server::WebrickServlet - def adapter(); end - - def adapter=(adapter); end - - def do_GET(request, response); end - - def initialize(server, adapter); end -end - -class YARD::Server::WebrickServlet -end - -class YARD::StubProxy - def _dump(_depth); end - - def initialize(path, transient=T.unsafe(nil)); end - - def method_missing(meth, *args, &block); end - FILELEN = ::T.let(nil, ::T.untyped) -end - -class YARD::StubProxy - def self._load(str); end -end - -class YARD::Tags::DefaultFactory - def parse_tag(tag_name, text); end - - def parse_tag_with_name(tag_name, text); end - - def parse_tag_with_options(tag_name, text); end - - def parse_tag_with_title_and_text(tag_name, text); end - - def parse_tag_with_types(tag_name, text); end - - def parse_tag_with_types_and_name(tag_name, text); end - - def parse_tag_with_types_and_title(tag_name, text); end - - def parse_tag_with_types_name_and_default(tag_name, text); end - TYPELIST_CLOSING_CHARS = ::T.let(nil, ::T.untyped) - TYPELIST_OPENING_CHARS = ::T.let(nil, ::T.untyped) -end - -class YARD::Tags::DefaultFactory -end - -class YARD::Tags::DefaultTag - def defaults(); end - - def initialize(tag_name, text, types=T.unsafe(nil), name=T.unsafe(nil), defaults=T.unsafe(nil)); end -end - -class YARD::Tags::DefaultTag -end - -class YARD::Tags::MethodDirective - SCOPE_MATCH = ::T.let(nil, ::T.untyped) -end - -class YARD::Tags::OptionTag - def initialize(tag_name, name, pair); end - - def pair(); end - - def pair=(pair); end -end - -class YARD::Tags::OptionTag -end - -module YARD::Tags::RefTag - def owner(); end - - def owner=(owner); end -end - -module YARD::Tags::RefTag -end - -class YARD::Tags::RefTagList - def initialize(tag_name, owner, name=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def owner(); end - - def owner=(owner); end - - def tag_name(); end - - def tag_name=(tag_name); end - - def tags(); end -end - -class YARD::Tags::RefTagList -end - -class YARD::Tags::TagFormatError -end - -class YARD::Tags::TagFormatError -end - -class YARD::Tags::TypesExplainer -end - -class YARD::Tags::TypesExplainer::CollectionType - def initialize(name, types); end - - def to_s(_singular=T.unsafe(nil)); end - - def types(); end - - def types=(types); end -end - -class YARD::Tags::TypesExplainer::CollectionType -end - -class YARD::Tags::TypesExplainer::FixedCollectionType -end - -class YARD::Tags::TypesExplainer::FixedCollectionType -end - -class YARD::Tags::TypesExplainer::HashCollectionType - def initialize(name, key_types, value_types); end - - def key_types(); end - - def key_types=(key_types); end - - def to_s(_singular=T.unsafe(nil)); end - - def value_types(); end - - def value_types=(value_types); end -end - -class YARD::Tags::TypesExplainer::HashCollectionType -end - -class YARD::Tags::TypesExplainer::Parser - include ::YARD::CodeObjects - def initialize(string); end - - def parse(); end - TOKENS = ::T.let(nil, ::T.untyped) -end - -class YARD::Tags::TypesExplainer::Parser - def self.parse(string); end -end - -class YARD::Tags::TypesExplainer::Type - def initialize(name); end - - def name(); end - - def name=(name); end - - def to_s(singular=T.unsafe(nil)); end -end - -class YARD::Tags::TypesExplainer::Type -end - -class YARD::Tags::TypesExplainer - def self.explain(*types); end - - def self.explain!(*types); end -end - -module YARD::Templates::Engine -end - -module YARD::Templates::Engine - def self.generate(objects, options=T.unsafe(nil)); end - - def self.register_template_path(path); end - - def self.render(options=T.unsafe(nil)); end - - def self.template(*path); end - - def self.template!(path, full_paths=T.unsafe(nil)); end - - def self.template_paths(); end - - def self.template_paths=(template_paths); end - - def self.with_serializer(object, serializer); end -end - -module YARD::Templates::ErbCache -end - -module YARD::Templates::ErbCache - def self.clear!(); end - - def self.method_for(filename); end -end - -module YARD::Templates::Helpers::BaseHelper - def format_object_title(object); end - - def format_object_type(object); end - - def format_source(value); end - - def format_types(list, brackets=T.unsafe(nil)); end - - def globals(); end - - def h(text); end - - def link_file(filename, title=T.unsafe(nil), anchor=T.unsafe(nil)); end - - def link_include_file(file); end - - def link_include_object(obj); end - - def link_object(obj, title=T.unsafe(nil)); end - - def link_url(url, title=T.unsafe(nil), params=T.unsafe(nil)); end - - def linkify(*args); end - - def object(); end - - def object=(object); end - - def owner(); end - - def run_verifier(list); end - - def serializer(); end - - def serializer=(serializer); end -end - -module YARD::Templates::Helpers::BaseHelper -end - -module YARD::Templates::Helpers::FilterHelper - def is_class?(object); end - - def is_method?(object); end - - def is_module?(object); end - - def is_namespace?(object); end -end - -module YARD::Templates::Helpers::FilterHelper -end - -module YARD::Templates::Helpers::HtmlHelper - include ::YARD::Templates::Helpers::MarkupHelper - include ::YARD::Templates::Helpers::HtmlSyntaxHighlightHelper - include ::YARD::Templates::Helpers::ModuleHelper - def anchor_for(object); end - - def charset(); end - - def format_object_name_list(objects); end - - def format_types(typelist, brackets=T.unsafe(nil)); end - - def h(text); end - - def html_markup_asciidoc(text); end - - def html_markup_html(text); end - - def html_markup_markdown(text); end - - def html_markup_none(text); end - - def html_markup_org(text); end - - def html_markup_pre(text); end - - def html_markup_rdoc(text); end - - def html_markup_ruby(source); end - - def html_markup_text(text); end - - def html_markup_textile(text); end - - def html_markup_textile_strict(text); end - - def html_syntax_highlight(source, type=T.unsafe(nil)); end - - def html_syntax_highlight_plain(source); end - - def htmlify(text, markup=T.unsafe(nil)); end - - def htmlify_line(*args); end - - def insert_include(text, markup=T.unsafe(nil)); end - - def link_file(filename, title=T.unsafe(nil), anchor=T.unsafe(nil)); end - - def link_include_file(file); end - - def link_include_object(obj); end - - def link_object(obj, title=T.unsafe(nil), anchor=T.unsafe(nil), relative=T.unsafe(nil)); end - - def link_url(url, title=T.unsafe(nil), params=T.unsafe(nil)); end - - def mtime(_file); end - - def mtime_url(obj, anchor=T.unsafe(nil), relative=T.unsafe(nil)); end - - def resolve_links(text); end - - def signature(meth, link=T.unsafe(nil), show_extras=T.unsafe(nil), full_attr_name=T.unsafe(nil)); end - - def signature_types(meth, link=T.unsafe(nil)); end - - def url_for(obj, anchor=T.unsafe(nil), relative=T.unsafe(nil)); end - - def url_for_file(filename, anchor=T.unsafe(nil)); end - - def url_for_frameset(); end - - def url_for_index(); end - - def url_for_list(type); end - - def url_for_main(); end - ASCIIDOC_ATTRIBUTES = ::T.let(nil, ::T.untyped) - URLMATCH = ::T.let(nil, ::T.untyped) -end - -module YARD::Templates::Helpers::HtmlHelper - def self.urlencode(text); end -end - -module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper - include ::YARD::Templates::Helpers::ModuleHelper - def html_syntax_highlight_ruby(source); end -end - -module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper -end - -class YARD::Templates::Helpers::Markup::RDocMarkdown - def fix_typewriter(html); end -end - -class YARD::Templates::Helpers::Markup::RDocMarkdown -end - -class YARD::Templates::Helpers::Markup::RDocMarkup - def from_path(); end - - def from_path=(from_path); end - - def initialize(text); end - - def to_html(); end -end - -YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP = RDoc::Markup - -class YARD::Templates::Helpers::Markup::RDocMarkup -end - -module YARD::Templates::Helpers::MarkupHelper - def load_markup_provider(type=T.unsafe(nil)); end - - def markup_class(type=T.unsafe(nil)); end - - def markup_file_contents(contents); end - - def markup_for_file(contents, filename); end - - def markup_provider(type=T.unsafe(nil)); end - MARKUP_EXTENSIONS = ::T.let(nil, ::T.untyped) - MARKUP_FILE_SHEBANG = ::T.let(nil, ::T.untyped) - MARKUP_PROVIDERS = ::T.let(nil, ::T.untyped) -end - -module YARD::Templates::Helpers::MarkupHelper - def self.clear_markup_cache(); end - - def self.markup_cache(); end - - def self.markup_cache=(markup_cache); end -end - -module YARD::Templates::Helpers::MethodHelper - def format_args(object); end - - def format_block(object); end - - def format_code(object, _show_lines=T.unsafe(nil)); end - - def format_constant(value); end - - def format_lines(object); end - - def format_return_types(object); end -end - -module YARD::Templates::Helpers::MethodHelper -end - -module YARD::Templates::Helpers::ModuleHelper - def prune_method_listing(list, hide_attributes=T.unsafe(nil)); end -end - -module YARD::Templates::Helpers::ModuleHelper -end - -module YARD::Templates::Helpers::TextHelper - def align_right(text, spacer=T.unsafe(nil), col=T.unsafe(nil)); end - - def h(text); end - - def hr(col=T.unsafe(nil), sep=T.unsafe(nil)); end - - def indent(text, len=T.unsafe(nil)); end - - def signature(meth); end - - def title_align_right(text, col=T.unsafe(nil)); end - - def wrap(text, col=T.unsafe(nil)); end -end - -module YARD::Templates::Helpers::TextHelper -end - -module YARD::Templates::Helpers::UMLHelper - def format_path(object); end - - def h(text); end - - def tidy(data); end - - def uml_visibility(object); end -end - -module YARD::Templates::Helpers::UMLHelper -end - -class YARD::Templates::Section - def <<(*args); end - - def ==(other); end - - def [](*args); end - - def any(item); end - - def eql?(other); end - - def initialize(name, *args); end - - def name(); end - - def name=(name); end - - def place(*args); end - - def push(*args); end - - def unshift(*args); end -end - -class YARD::Templates::Section -end - -module YARD::Templates::Template - include ::YARD::Templates::ErbCache - include ::YARD::Templates::Helpers::BaseHelper - include ::YARD::Templates::Helpers::MethodHelper - def T(*path); end - - def class(); end - - def class=(arg); end - - def erb(section, &block); end - - def erb_file_for(section); end - - def erb_with(content, filename=T.unsafe(nil)); end - - def file(basename, allow_inherited=T.unsafe(nil)); end - - def init(); end - - def initialize(opts=T.unsafe(nil)); end - - def inspect(); end - - def options(); end - - def options=(value); end - - def run(opts=T.unsafe(nil), sects=T.unsafe(nil), start_at=T.unsafe(nil), break_first=T.unsafe(nil), &block); end - - def section(); end - - def section=(section); end - - def sections(*args); end - - def superb(sect=T.unsafe(nil), &block); end - - def yieldall(opts=T.unsafe(nil), &block); end -end - -module YARD::Templates::Template::ClassMethods - def S(*args); end - - def T(*path); end - - def find_file(basename); end - - def find_nth_file(basename, index=T.unsafe(nil)); end - - def full_path(); end - - def full_path=(full_path); end - - def full_paths(); end - - def initialize(path, full_paths); end - - def is_a?(klass); end - - def new(*args); end - - def path(); end - - def path=(path); end - - def reset_full_paths(); end - - def run(*args); end -end - -module YARD::Templates::Template::ClassMethods -end - -module YARD::Templates::Template - def self.extra_includes(); end - - def self.extra_includes=(extra_includes); end - - def self.include_extra(template, options); end - - def self.included(klass); end -end - -class YARD::Verifier - def add_expressions(*expressions); end - - def call(object); end - - def expressions(); end - - def expressions=(value); end - - def initialize(*expressions); end - - def method_missing(sym, *args, &block); end - - def o(); end - - def object(); end - - def run(list); end - NILCLASS_METHODS = ::T.let(nil, ::T.untyped) -end - -class YARD::Verifier -end - -module YARDSorbet::Directives - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::AbstractDSLHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::EnumsHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::IncludeHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::MixesInClassMethodsHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::SigHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::Handlers::StructClassHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::Handlers::StructPropHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::NodeUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::SigToYARD - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class YARDSorbet::TStructProp - def self.inherited(s); end -end - -module YARDSorbet::TagUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Zlib::Deflate - def initialize(*arg); end -end - -class Zlib::GzipReader - def initialize(*arg); end -end - -class Zlib::GzipWriter - def initialize(*arg); end -end - -class Zlib::InProgressError -end - -class Zlib::InProgressError -end - -class Zlib::Inflate - def initialize(*arg); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/bundler-audit/all/bundler-audit.rbi b/sorbet/rbi/sorbet-typed/lib/bundler-audit/all/bundler-audit.rbi deleted file mode 100644 index b63a9fb9..00000000 --- a/sorbet/rbi/sorbet-typed/lib/bundler-audit/all/bundler-audit.rbi +++ /dev/null @@ -1,11 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/bundler-audit/all/bundler-audit.rbi -# -# typed: strict - -class Bundler::Audit::Task < ::Rake::TaskLib -end diff --git a/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi b/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi deleted file mode 100644 index 4ac93aca..00000000 --- a/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +++ /dev/null @@ -1,645 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rake/all/rake.rbi -# -# typed: strict - -module Rake - def self.add_rakelib(*files); end - def self.application; end - def self.application=(app); end - def self.each_dir_parent(dir); end - def self.from_pathname(path); end - def self.load_rakefile(path); end - def self.original_dir; end - def self.suggested_thread_count; end - def self.with_application(block_application = nil); end - extend Rake::FileUtilsExt -end -module Rake::Version -end -class Module - def rake_extension(method); end -end -class String - def ext(newext = nil); end - def pathmap(spec = nil, &block); end - def pathmap_explode; end - def pathmap_partial(n); end - def pathmap_replace(patterns, &block); end -end -module Rake::Win32 - def self.normalize(path); end - def self.win32_system_dir; end - def self.windows?; end -end -class Rake::Win32::Win32HomeError < RuntimeError -end -class Rake::LinkedList - def ==(other); end - def conj(item); end - def each; end - def empty?; end - def head; end - def initialize(head, tail = nil); end - def inspect; end - def self.cons(head, tail); end - def self.empty; end - def self.make(*args); end - def tail; end - def to_s; end - include Enumerable -end -class Rake::LinkedList::EmptyLinkedList < Rake::LinkedList - def empty?; end - def initialize; end - def self.cons(head, tail); end -end -class Rake::CpuCounter - def count; end - def count_with_default(default = nil); end - def self.count; end -end -class Rake::Scope < Rake::LinkedList - def path; end - def path_with_task_name(task_name); end - def trim(n); end -end -class Rake::Scope::EmptyScope < Rake::LinkedList::EmptyLinkedList - def path; end - def path_with_task_name(task_name); end -end -class Rake::TaskArgumentError < ArgumentError -end -class Rake::RuleRecursionOverflowError < StandardError - def add_target(target); end - def initialize(*args); end - def message; end -end -module Rake::TaskManager - def [](task_name, scopes = nil); end - def add_location(task); end - def attempt_rule(task_name, task_pattern, args, extensions, block, level); end - def clear; end - def create_rule(*args, &block); end - def current_scope; end - def define_task(task_class, *args, &block); end - def enhance_with_matching_rule(task_name, level = nil); end - def find_location; end - def generate_did_you_mean_suggestions(task_name); end - def generate_message_for_undefined_task(task_name); end - def generate_name; end - def get_description(task); end - def in_namespace(name); end - def initialize; end - def intern(task_class, task_name); end - def last_description; end - def last_description=(arg0); end - def lookup(task_name, initial_scope = nil); end - def lookup_in_scope(name, scope); end - def make_sources(task_name, task_pattern, extensions); end - def resolve_args(args); end - def resolve_args_with_dependencies(args, hash); end - def resolve_args_without_dependencies(args); end - def self.record_task_metadata; end - def self.record_task_metadata=(arg0); end - def synthesize_file_task(task_name); end - def tasks; end - def tasks_in_scope(scope); end - def trace_rule(level, message); end -end -module Rake::Cloneable - def initialize_copy(source); end -end -module FileUtils - def create_shell_runner(cmd); end - def ruby(*args, **options, &block); end - def safe_ln(*args, **options); end - def set_verbose_option(options); end - def sh(*cmd, &block); end - def sh_show_command(cmd); end - def split_all(path); end -end -module Rake::FileUtilsExt - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def mv(*args, **options, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def safe_unlink(*args, **options, &block); end - def self.nowrite_flag; end - def self.nowrite_flag=(arg0); end - def self.verbose_flag; end - def self.verbose_flag=(arg0); end - def symlink(*args, **options, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - extend Rake::FileUtilsExt - include FileUtils -end -class Rake::FileList - def &(*args, &block); end - def *(other); end - def +(*args, &block); end - def -(*args, &block); end - def <<(obj); end - def <=>(*args, &block); end - def ==(array); end - def [](*args, &block); end - def []=(*args, &block); end - def add(*filenames); end - def add_matching(pattern); end - def all?(*args, &block); end - def any?(*args, &block); end - def append(*args, &block); end - def assoc(*args, &block); end - def at(*args, &block); end - def bsearch(*args, &block); end - def bsearch_index(*args, &block); end - def chain(*args, &block); end - def chunk(*args, &block); end - def chunk_while(*args, &block); end - def clear(*args, &block); end - def clear_exclude; end - def collect!(*args, &block); end - def collect(*args, &block); end - def collect_concat(*args, &block); end - def combination(*args, &block); end - def compact!(*args, &block); end - def compact(*args, &block); end - def concat(*args, &block); end - def count(*args, &block); end - def cycle(*args, &block); end - def delete(*args, &block); end - def delete_at(*args, &block); end - def delete_if(*args, &block); end - def detect(*args, &block); end - def difference(*args, &block); end - def dig(*args, &block); end - def drop(*args, &block); end - def drop_while(*args, &block); end - def each(*args, &block); end - def each_cons(*args, &block); end - def each_entry(*args, &block); end - def each_index(*args, &block); end - def each_slice(*args, &block); end - def each_with_index(*args, &block); end - def each_with_object(*args, &block); end - def egrep(pattern, *options); end - def empty?(*args, &block); end - def entries(*args, &block); end - def exclude(*patterns, &block); end - def excluded_from_list?(fn); end - def existing!; end - def existing; end - def ext(newext = nil); end - def fetch(*args, &block); end - def fill(*args, &block); end - def filter!(*args, &block); end - def filter(*args, &block); end - def find(*args, &block); end - def find_all(*args, &block); end - def find_index(*args, &block); end - def first(*args, &block); end - def flat_map(*args, &block); end - def flatten!(*args, &block); end - def flatten(*args, &block); end - def grep(*args, &block); end - def grep_v(*args, &block); end - def group_by(*args, &block); end - def gsub!(pat, rep); end - def gsub(pat, rep); end - def import(array); end - def include(*filenames); end - def include?(*args, &block); end - def index(*args, &block); end - def initialize(*patterns); end - def inject(*args, &block); end - def insert(*args, &block); end - def inspect(*args, &block); end - def is_a?(klass); end - def join(*args, &block); end - def keep_if(*args, &block); end - def kind_of?(klass); end - def last(*args, &block); end - def lazy(*args, &block); end - def length(*args, &block); end - def map!(*args, &block); end - def map(*args, &block); end - def max(*args, &block); end - def max_by(*args, &block); end - def member?(*args, &block); end - def min(*args, &block); end - def min_by(*args, &block); end - def minmax(*args, &block); end - def minmax_by(*args, &block); end - def none?(*args, &block); end - def one?(*args, &block); end - def pack(*args, &block); end - def partition(&block); end - def pathmap(spec = nil, &block); end - def permutation(*args, &block); end - def pop(*args, &block); end - def prepend(*args, &block); end - def product(*args, &block); end - def push(*args, &block); end - def rassoc(*args, &block); end - def reduce(*args, &block); end - def reject!(*args, &block); end - def reject(*args, &block); end - def repeated_combination(*args, &block); end - def repeated_permutation(*args, &block); end - def replace(*args, &block); end - def resolve; end - def resolve_add(fn); end - def resolve_exclude; end - def reverse!(*args, &block); end - def reverse(*args, &block); end - def reverse_each(*args, &block); end - def rindex(*args, &block); end - def rotate!(*args, &block); end - def rotate(*args, &block); end - def sample(*args, &block); end - def select!(*args, &block); end - def select(*args, &block); end - def self.[](*args); end - def self.glob(pattern, *args); end - def shelljoin(*args, &block); end - def shift(*args, &block); end - def shuffle!(*args, &block); end - def shuffle(*args, &block); end - def size(*args, &block); end - def slice!(*args, &block); end - def slice(*args, &block); end - def slice_after(*args, &block); end - def slice_before(*args, &block); end - def slice_when(*args, &block); end - def sort!(*args, &block); end - def sort(*args, &block); end - def sort_by!(*args, &block); end - def sort_by(*args, &block); end - def sub!(pat, rep); end - def sub(pat, rep); end - def sum(*args, &block); end - def take(*args, &block); end - def take_while(*args, &block); end - def to_a; end - def to_ary; end - def to_h(*args, &block); end - def to_s; end - def to_set(*args, &block); end - def transpose(*args, &block); end - def union(*args, &block); end - def uniq!(*args, &block); end - def uniq(*args, &block); end - def unshift(*args, &block); end - def values_at(*args, &block); end - def zip(*args, &block); end - def |(*args, &block); end - include Rake::Cloneable -end -class Rake::Promise - def chore; end - def complete?; end - def discard; end - def error?; end - def initialize(args, &block); end - def recorder; end - def recorder=(arg0); end - def result?; end - def stat(*args); end - def value; end - def work; end -end -class Rake::ThreadPool - def __queue__; end - def future(*args, &block); end - def gather_history; end - def history; end - def initialize(thread_count); end - def join; end - def process_queue_item; end - def safe_thread_count; end - def start_thread; end - def stat(event, data = nil); end - def statistics; end -end -module Rake::PrivateReader - def self.included(base); end -end -module Rake::PrivateReader::ClassMethods - def private_reader(*names); end -end -class Rake::ThreadHistoryDisplay - def initialize(stats); end - def items; end - def rename(hash, key, renames); end - def show; end - def stats; end - def threads; end - extend Rake::PrivateReader::ClassMethods - include Rake::PrivateReader -end -module Rake::TraceOutput - def trace_on(out, *strings); end -end -class Rake::CommandLineOptionError < StandardError -end -class Rake::Application - def add_import(fn); end - def add_loader(ext, loader); end - def collect_command_line_tasks(args); end - def default_task_name; end - def deprecate(old_usage, new_usage, call_site); end - def display_cause_details(ex); end - def display_error_message(ex); end - def display_exception_backtrace(ex); end - def display_exception_details(ex); end - def display_exception_details_seen; end - def display_exception_message_details(ex); end - def display_prerequisites; end - def display_tasks_and_comments; end - def dynamic_width; end - def dynamic_width_stty; end - def dynamic_width_tput; end - def exit_because_of_exception(ex); end - def find_rakefile_location; end - def glob(path, &block); end - def handle_options(argv); end - def has_cause?(ex); end - def has_chain?(exception); end - def have_rakefile; end - def init(app_name = nil, argv = nil); end - def initialize; end - def invoke_task(task_string); end - def load_imports; end - def load_rakefile; end - def name; end - def options; end - def original_dir; end - def parse_task_string(string); end - def print_rakefile_directory(location); end - def rake_require(file_name, paths = nil, loaded = nil); end - def rakefile; end - def rakefile_location(backtrace = nil); end - def raw_load_rakefile; end - def run(argv = nil); end - def run_with_threads; end - def select_tasks_to_show(options, show_tasks, value); end - def select_trace_output(options, trace_option, value); end - def set_default_options; end - def sort_options(options); end - def standard_exception_handling; end - def standard_rake_options; end - def standard_system_dir; end - def system_dir; end - def terminal_columns; end - def terminal_columns=(arg0); end - def terminal_width; end - def thread_pool; end - def top_level; end - def top_level_tasks; end - def trace(*strings); end - def truncate(string, width); end - def truncate_output?; end - def tty_output=(arg0); end - def tty_output?; end - def unix?; end - def windows?; end - include Rake::TaskManager - include Rake::TraceOutput -end -class Rake::PseudoStatus - def >>(n); end - def exited?; end - def exitstatus; end - def initialize(code = nil); end - def stopped?; end - def to_i; end -end -class Rake::TaskArguments - def [](index); end - def each(&block); end - def extras; end - def fetch(*args, &block); end - def has_key?(key); end - def initialize(names, values, parent = nil); end - def inspect; end - def key?(key); end - def lookup(name); end - def method_missing(sym, *args); end - def names; end - def new_scope(names); end - def to_a; end - def to_hash; end - def to_s; end - def values_at(*keys); end - def with_defaults(defaults); end - include Enumerable -end -class Rake::InvocationChain < Rake::LinkedList - def append(invocation); end - def member?(invocation); end - def prefix; end - def self.append(invocation, chain); end - def to_s; end -end -class Rake::InvocationChain::EmptyInvocationChain < Rake::LinkedList::EmptyLinkedList - def append(invocation); end - def member?(obj); end - def to_s; end -end -module Rake::InvocationExceptionMixin - def chain; end - def chain=(value); end -end -class Rake::Task - def actions; end - def add_chain_to(exception, new_chain); end - def add_comment(comment); end - def add_description(description); end - def all_prerequisite_tasks; end - def already_invoked; end - def application; end - def application=(arg0); end - def arg_description; end - def arg_names; end - def clear; end - def clear_actions; end - def clear_args; end - def clear_comments; end - def clear_prerequisites; end - def collect_prerequisites(seen); end - def comment; end - def comment=(comment); end - def enhance(deps = nil, &block); end - def execute(args = nil); end - def first_sentence(string); end - def format_trace_flags; end - def full_comment; end - def initialize(task_name, app); end - def inspect; end - def investigation; end - def invoke(*args); end - def invoke_prerequisites(task_args, invocation_chain); end - def invoke_prerequisites_concurrently(task_args, invocation_chain); end - def invoke_with_call_chain(task_args, invocation_chain); end - def locations; end - def lookup_prerequisite(prerequisite_name); end - def name; end - def name_with_args; end - def needed?; end - def order_only_prerequisites; end - def prereqs; end - def prerequisite_tasks; end - def prerequisites; end - def reenable; end - def scope; end - def self.[](task_name); end - def self.clear; end - def self.create_rule(*args, &block); end - def self.define_task(*args, &block); end - def self.format_deps(deps); end - def self.scope_name(scope, task_name); end - def self.task_defined?(task_name); end - def self.tasks; end - def set_arg_names(args); end - def source; end - def sources; end - def sources=(arg0); end - def timestamp; end - def to_s; end - def transform_comments(separator, &block); end - def |(deps); end -end -class Rake::EarlyTime - def <=>(other); end - def self.allocate; end - def self.instance; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::FileTask < Rake::Task - def needed?; end - def out_of_date?(stamp); end - def self.scope_name(scope, task_name); end - def timestamp; end -end -class Rake::FileCreationTask < Rake::FileTask - def needed?; end - def timestamp; end -end -class Rake::MultiTask < Rake::Task - def invoke_prerequisites(task_args, invocation_chain); end -end -module Rake::DSL - def cd(*args, **options, &block); end - def chdir(*args, **options, &block); end - def chmod(*args, **options, &block); end - def chmod_R(*args, **options, &block); end - def chown(*args, **options, &block); end - def chown_R(*args, **options, &block); end - def copy(*args, **options, &block); end - def cp(*args, **options, &block); end - def cp_lr(*args, **options, &block); end - def cp_r(*args, **options, &block); end - def desc(description); end - def directory(*args, &block); end - def file(*args, &block); end - def file_create(*args, &block); end - def import(*fns); end - def install(*args, **options, &block); end - def link(*args, **options, &block); end - def ln(*args, **options, &block); end - def ln_s(*args, **options, &block); end - def ln_sf(*args, **options, &block); end - def makedirs(*args, **options, &block); end - def mkdir(*args, **options, &block); end - def mkdir_p(*args, **options, &block); end - def mkpath(*args, **options, &block); end - def move(*args, **options, &block); end - def multitask(*args, &block); end - def mv(*args, **options, &block); end - def namespace(name = nil, &block); end - def nowrite(value = nil); end - def rake_check_options(options, *optdecl); end - def rake_output_message(message); end - def remove(*args, **options, &block); end - def rm(*args, **options, &block); end - def rm_f(*args, **options, &block); end - def rm_r(*args, **options, &block); end - def rm_rf(*args, **options, &block); end - def rmdir(*args, **options, &block); end - def rmtree(*args, **options, &block); end - def ruby(*args, **options, &block); end - def rule(*args, &block); end - def safe_ln(*args, **options); end - def safe_unlink(*args, **options, &block); end - def sh(*cmd, &block); end - def split_all(path); end - def symlink(*args, **options, &block); end - def task(*args, &block); end - def touch(*args, **options, &block); end - def verbose(value = nil); end - def when_writing(msg = nil); end - include Rake::FileUtilsExt -end -class Rake::DefaultLoader - def load(fn); end -end -class Rake::LateTime - def <=>(other); end - def self.allocate; end - def self.instance; end - def self.new(*arg0); end - def to_s; end - extend Singleton::SingletonClassMethods - include Comparable - include Singleton -end -class Rake::NameSpace - def [](name); end - def initialize(task_manager, scope_list); end - def scope; end - def tasks; end -end -module Rake::Backtrace - def self.collapse(backtrace); end -end -class Rake::TaskLib - include Rake::Cloneable - include Rake::DSL -end diff --git a/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi b/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi deleted file mode 100644 index f11b3ecc..00000000 --- a/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +++ /dev/null @@ -1,24 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rspec-core/all/rspec-core.rbi -# -# typed: strict - -module RSpec::Core::ShellEscape - def conditionally_quote(id); end - def escape(shell_command); end - def quote(argument); end - def self.conditionally_quote(id); end - def self.escape(shell_command); end - def self.quote(argument); end - def self.shell_allows_unquoted_ids?; end - def shell_allows_unquoted_ids?; end -end -class RSpec::Core::RakeTask < ::Rake::TaskLib - include ::Rake::DSL - include RSpec::Core::ShellEscape - def initialize(*args, &task_block); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi b/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi deleted file mode 100644 index e2774bd2..00000000 --- a/sorbet/rbi/sorbet-typed/lib/rubocop-performance/~>1.6/rubocop-performance.rbi +++ /dev/null @@ -1,149 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rubocop-performance/~>1.6/rubocop-performance.rbi -# -# typed: strict - -module RuboCop::Performance - CONFIG = ::T.let(nil, ::T.untyped) -end - -module RuboCop::Performance::Version - STRING = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::BindCall - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Caller - MSG_BRACE = ::T.let(nil, ::T.untyped) - MSG_FIRST = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::CaseWhenSplat - ARRAY_MSG = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Casecmp - CASE_METHODS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ChainArrayAllocation - ALWAYS_RETURNS_NEW_ARRAY = ::T.let(nil, ::T.untyped) - HAS_MUTATION_ALTERNATIVE = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ::T.let(nil, ::T.untyped) - RETURN_NEW_ARRAY_WHEN_ARGS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::CompareWithBlock - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Count - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeletePrefix - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DeleteSuffix - MSG = ::T.let(nil, ::T.untyped) - PREFERRED_METHODS = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Detect - MSG = ::T.let(nil, ::T.untyped) - REVERSE_MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::DoubleStartEndWith - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::EndWith - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FixedSize - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::FlatMap - FLATTEN_MULTIPLE_LEVELS = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::OpenStruct - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RangeInclude - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantBlockCall - CLOSE_PAREN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - OPEN_PAREN = ::T.let(nil, ::T.untyped) - SPACE = ::T.let(nil, ::T.untyped) - YIELD = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMatch - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RedundantMerge - AREF_ASGN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - WITH_MODIFIER_CORRECTION = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::RegexpMatch - MATCH_NODE_PATTERN = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TYPES_IMPLEMENTING_MATCH = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::ReverseEach - MSG = ::T.let(nil, ::T.untyped) - UNDERSCORE = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::Size - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StartWith - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::StringReplacement - BANG = ::T.let(nil, ::T.untyped) - DELETE = ::T.let(nil, ::T.untyped) - DETERMINISTIC_REGEX = ::T.let(nil, ::T.untyped) - MSG = ::T.let(nil, ::T.untyped) - TR = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::TimesMap - MESSAGE = ::T.let(nil, ::T.untyped) - MESSAGE_ONLY_IF = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UnfreezeString - MSG = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cop::Performance::UriDefaultParser - MSG = ::T.let(nil, ::T.untyped) -end diff --git a/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi b/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi deleted file mode 100644 index 8c3fd247..00000000 --- a/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +++ /dev/null @@ -1,12 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/rubocop/>=1.8/rubocop.rbi -# -# typed: strict - -class RuboCop::RakeTask < ::Rake::TaskLib - def initialize(name = :rubocop, *args, &task_block); end -end diff --git a/sorbet/rbi/sorbet-typed/lib/thor/all/thor.rbi b/sorbet/rbi/sorbet-typed/lib/thor/all/thor.rbi deleted file mode 100644 index 0238e1ba..00000000 --- a/sorbet/rbi/sorbet-typed/lib/thor/all/thor.rbi +++ /dev/null @@ -1,905 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/thor/all/thor.rbi -# -# typed: ignore - -class Thor - include(::Thor::Base) - include(::Thor::Invocation) - include(::Thor::Shell) - extend(::Thor::Base::ClassMethods) - extend(::Thor::Invocation::ClassMethods) - - def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end - - class << self - def check_unknown_options!(options = T.unsafe(nil)); end - def check_unknown_options?(config); end - def command_help(shell, command_name); end - def default_command(meth = T.unsafe(nil)); end - def default_task(meth = T.unsafe(nil)); end - def deprecation_warning(message); end - def desc(usage, description, options = T.unsafe(nil)); end - def disable_required_check!(*command_names); end - def disable_required_check?(command); end - def help(shell, subcommand = T.unsafe(nil)); end - def long_desc(long_description, options = T.unsafe(nil)); end - def map(mappings = T.unsafe(nil), **kw); end - def method_option(name, options = T.unsafe(nil)); end - def method_options(options = T.unsafe(nil)); end - def option(name, options = T.unsafe(nil)); end - def options(options = T.unsafe(nil)); end - def package_name(name, _ = T.unsafe(nil)); end - def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end - def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end - def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end - def stop_on_unknown_option!(*command_names); end - def stop_on_unknown_option?(command); end - def subcommand(subcommand, subcommand_class); end - def subcommand_classes; end - def subcommands; end - def subtask(subcommand, subcommand_class); end - def subtasks; end - def task_help(shell, command_name); end - - protected - - def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end - def baseclass; end - def create_command(meth); end - def create_task(meth); end - def disable_required_check; end - def dispatch(meth, given_args, given_opts, config); end - def dynamic_command_class; end - def find_command_possibilities(meth); end - def find_task_possibilities(meth); end - def initialize_added; end - def normalize_command_name(meth); end - def normalize_task_name(meth); end - def retrieve_command_name(args); end - def retrieve_task_name(args); end - def stop_on_unknown_option; end - def subcommand_help(cmd); end - def subtask_help(cmd); end - end -end - -module Thor::Actions - mixes_in_class_methods(::Thor::Actions::ClassMethods) - - def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end - - def action(instance); end - def add_file(destination, *args, &block); end - def add_link(destination, *args); end - def append_file(path, *args, &block); end - def append_to_file(path, *args, &block); end - def apply(path, config = T.unsafe(nil)); end - def behavior; end - def behavior=(_arg0); end - def chmod(path, mode, config = T.unsafe(nil)); end - def comment_lines(path, flag, *args); end - def copy_file(source, *args, &block); end - def create_file(destination, *args, &block); end - def create_link(destination, *args); end - def destination_root; end - def destination_root=(root); end - def directory(source, *args, &block); end - def empty_directory(destination, config = T.unsafe(nil)); end - def find_in_source_paths(file); end - def get(source, *args, &block); end - def gsub_file(path, flag, *args, &block); end - def in_root; end - def inject_into_class(path, klass, *args, &block); end - def inject_into_file(destination, *args, &block); end - def inject_into_module(path, module_name, *args, &block); end - def insert_into_file(destination, *args, &block); end - def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end - def link_file(source, *args); end - def prepend_file(path, *args, &block); end - def prepend_to_file(path, *args, &block); end - def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end - def remove_dir(path, config = T.unsafe(nil)); end - def remove_file(path, config = T.unsafe(nil)); end - def run(command, config = T.unsafe(nil)); end - def run_ruby_script(command, config = T.unsafe(nil)); end - def source_paths; end - def template(source, *args, &block); end - def thor(command, *args); end - def uncomment_lines(path, flag, *args); end - - protected - - def _cleanup_options_and_set(options, key); end - def _shared_configuration; end - - private - - def capture(*args); end - def concat(string); end - def output_buffer; end - def output_buffer=(_arg0); end - def with_output_buffer(buf = T.unsafe(nil)); end - - class << self - def included(base); end - end -end - -class Thor::Actions::CapturableERB < ::ERB - def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end -end - -module Thor::Actions::ClassMethods - def add_runtime_options!; end - def source_paths; end - def source_paths_for_search; end - def source_root(path = T.unsafe(nil)); end -end - -class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory - def initialize(base, destination, data, config = T.unsafe(nil)); end - - def data; end - def identical?; end - def invoke!; end - def render; end - - protected - - def force_on_collision?; end - def force_or_skip_or_conflict(force, skip, &block); end - def on_conflict_behavior(&block); end -end - -class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile - def data; end - def exists?; end - def identical?; end - def invoke!; end -end - -class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory - def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end - - def invoke!; end - def revoke!; end - def source; end - - protected - - def execute!; end - def file_level_lookup(previous_lookup); end - def files(lookup); end -end - -class Thor::Actions::EmptyDirectory - def initialize(base, destination, config = T.unsafe(nil)); end - - def base; end - def config; end - def destination; end - def exists?; end - def given_destination; end - def invoke!; end - def relative_destination; end - def revoke!; end - - protected - - def convert_encoded_instructions(filename); end - def destination=(destination); end - def invoke_with_conflict_check(&block); end - def on_conflict_behavior; end - def on_file_clash_behavior; end - def pretend?; end - def say_status(status, color); end -end - -class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory - def initialize(base, destination, data, config); end - - def behavior; end - def flag; end - def invoke!; end - def replacement; end - def revoke!; end - - protected - - def replace!(regexp, string, force); end - def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end -end - -Thor::Actions::WARNINGS = T.let(T.unsafe(nil), T::Hash[T.untyped, T.untyped]) - -class Thor::AmbiguousCommandError < ::Thor::Error -end - -Thor::AmbiguousTaskError = Thor::AmbiguousCommandError - -class Thor::Argument - def initialize(name, options = T.unsafe(nil)); end - - def banner; end - def default; end - def description; end - def enum; end - def human_name; end - def name; end - def required; end - def required?; end - def show_default?; end - def type; end - def usage; end - - protected - - def default_banner; end - def valid_type?(type); end - def validate!; end -end - -Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), T::Array[T.untyped]) - -class Thor::Arguments - def initialize(arguments = T.unsafe(nil)); end - - def parse(args); end - def remaining; end - - private - - def check_requirement!; end - def current_is_value?; end - def last?; end - def no_or_skip?(arg); end - def parse_array(name); end - def parse_hash(name); end - def parse_numeric(name); end - def parse_string(name); end - def peek; end - def shift; end - def unshift(arg); end - - class << self - def parse(*args); end - def split(args); end - end -end - -Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp) - -module Thor::Base - include(::Thor::Invocation) - include(::Thor::Shell) - - mixes_in_class_methods(::Thor::Base::ClassMethods) - - def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end - - def args; end - def args=(_arg0); end - def options; end - def options=(_arg0); end - def parent_options; end - def parent_options=(_arg0); end - - class << self - def included(base); end - def register_klass_file(klass); end - def shell; end - def shell=(_arg0); end - def subclass_files; end - def subclasses; end - end -end - -module Thor::Base::ClassMethods - def all_commands; end - def all_tasks; end - def allow_incompatible_default_type!; end - def argument(name, options = T.unsafe(nil)); end - def arguments; end - def attr_accessor(*_arg0); end - def attr_reader(*_arg0); end - def attr_writer(*_arg0); end - def check_default_type; end - def check_default_type!; end - def check_unknown_options; end - def check_unknown_options!; end - def check_unknown_options?(config); end - def class_option(name, options = T.unsafe(nil)); end - def class_options(options = T.unsafe(nil)); end - def commands; end - def disable_required_check?(command_name); end - def exit_on_failure?; end - def group(name = T.unsafe(nil)); end - def handle_argument_error(command, error, args, arity); end - def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end - def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end - def namespace(name = T.unsafe(nil)); end - def no_commands(&block); end - def no_commands?; end - def no_commands_context; end - def no_tasks(&block); end - def public_command(*names); end - def public_task(*names); end - def remove_argument(*names); end - def remove_class_option(*names); end - def remove_command(*names); end - def remove_task(*names); end - def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end - def stop_on_unknown_option?(command_name); end - def strict_args_position; end - def strict_args_position!; end - def strict_args_position?(config); end - def tasks; end - - protected - - def baseclass; end - def basename; end - def build_option(name, options, scope); end - def build_options(options, scope); end - def class_options_help(shell, groups = T.unsafe(nil)); end - def create_command(meth); end - def create_task(meth); end - def dispatch(command, given_args, given_opts, config); end - def find_and_refresh_command(name); end - def find_and_refresh_task(name); end - def from_superclass(method, default = T.unsafe(nil)); end - def inherited(klass); end - def initialize_added; end - def is_thor_reserved_word?(word, type); end - def method_added(meth); end - def print_options(shell, options, group_name = T.unsafe(nil)); end -end - -class Thor::Command < ::Struct - Elem = type_member {{fixed: T.untyped}} - - def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end - - def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end - def hidden?; end - def run(instance, args = T.unsafe(nil)); end - - protected - - def handle_argument_error?(instance, error, caller); end - def handle_no_method_error?(instance, error, caller); end - def local_method?(instance, name); end - def not_debugging?(instance); end - def private_method?(instance); end - def public_method?(instance); end - def required_arguments_for(klass, usage); end - def required_options; end - def sans_backtrace(backtrace, caller); end - - private - - def initialize_copy(other); end -end - -Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp) - -module Thor::CoreExt -end - -class Thor::CoreExt::HashWithIndifferentAccess < ::Hash - K = type_member {{fixed: T.untyped}} - V = type_member {{fixed: T.untyped}} - Elem = type_member {{fixed: T.untyped}} - - def initialize(hash = T.unsafe(nil)); end - - def [](key); end - def []=(key, value); end - def delete(key); end - def fetch(key, *args); end - def key?(key); end - def merge(other); end - def merge!(other); end - def replace(other_hash); end - def reverse_merge(other); end - def reverse_merge!(other_hash); end - def to_hash; end - def values_at(*indices); end - - protected - - def convert_key(key); end - def method_missing(method, *args); end -end - -Thor::Correctable = DidYouMean::Correctable - -class Thor::DynamicCommand < ::Thor::Command - Elem = type_member {{fixed: T.untyped}} - - def initialize(name, options = T.unsafe(nil)); end - - def run(instance, args = T.unsafe(nil)); end -end - -Thor::DynamicTask = Thor::DynamicCommand - -class Thor::Error < ::StandardError -end - -class Thor::Group - include(::Thor::Base) - include(::Thor::Invocation) - include(::Thor::Shell) - extend(::Thor::Base::ClassMethods) - extend(::Thor::Invocation::ClassMethods) - - - protected - - def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end - - class << self - def class_options_help(shell, groups = T.unsafe(nil)); end - def desc(description = T.unsafe(nil)); end - def get_options_from_invocations(group_options, base_options); end - def handle_argument_error(command, error, _args, arity); end - def help(shell); end - def invocation_blocks; end - def invocations; end - def invoke(*names, &block); end - def invoke_from_option(*names, &block); end - def printable_commands(*_arg0); end - def printable_tasks(*_arg0); end - def remove_invocation(*names); end - - protected - - def banner; end - def baseclass; end - def create_command(meth); end - def create_task(meth); end - def dispatch(command, given_args, given_opts, config); end - def self_command; end - def self_task; end - end -end - -Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), T::Array[T.untyped]) - -class Thor::HiddenCommand < ::Thor::Command - Elem = type_member {{fixed: T.untyped}} - - def hidden?; end -end - -Thor::HiddenTask = Thor::HiddenCommand - -module Thor::Invocation - mixes_in_class_methods(::Thor::Invocation::ClassMethods) - - def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end - - def current_command_chain; end - def invoke(name = T.unsafe(nil), *args); end - def invoke_all; end - def invoke_command(command, *args); end - def invoke_task(command, *args); end - def invoke_with_padding(*args); end - - protected - - def _parse_initialization_options(args, opts, config); end - def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end - def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end - def _shared_configuration; end - - class << self - def included(base); end - end -end - -module Thor::Invocation::ClassMethods - def prepare_for_invocation(key, name); end -end - -class Thor::InvocationError < ::Thor::Error -end - -module Thor::LineEditor - class << self - def best_available; end - def readline(prompt, options = T.unsafe(nil)); end - end -end - -class Thor::LineEditor::Basic - def initialize(prompt, options); end - - def options; end - def prompt; end - def readline; end - - private - - def echo?; end - def get_input; end - - class << self - def available?; end - end -end - -class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic - def readline; end - - private - - def add_to_history?; end - def completion_options; end - def completion_proc; end - def use_path_completion?; end - - class << self - def available?; end - end -end - -class Thor::LineEditor::Readline::PathCompletion - def initialize(text); end - - def matches; end - - private - - def absolute_matches; end - def base_path; end - def glob_pattern; end - def relative_matches; end - def text; end -end - -class Thor::MalformattedArgumentError < ::Thor::InvocationError -end - -class Thor::NestedContext - def initialize; end - - def enter; end - def entered?; end - - private - - def pop; end - def push; end -end - -class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker - def initialize(dictionary); end -end - -class Thor::Option < ::Thor::Argument - def initialize(name, options = T.unsafe(nil)); end - - def aliases; end - def array?; end - def boolean?; end - def group; end - def hash?; end - def hide; end - def human_name; end - def lazy_default; end - def numeric?; end - def repeatable; end - def string?; end - def switch_name; end - def usage(padding = T.unsafe(nil)); end - - protected - - def dasherize(str); end - def dasherized?; end - def undasherize(str); end - def validate!; end - def validate_default_type!; end - - class << self - def parse(key, value); end - end -end - -Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), T::Array[T.untyped]) - -class Thor::Options < ::Thor::Arguments - def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end - - def check_unknown!; end - def parse(args); end - def peek; end - def remaining; end - - protected - - def assign_result!(option, result); end - def current_is_switch?; end - def current_is_switch_formatted?; end - def current_is_value?; end - def normalize_switch(arg); end - def parse_boolean(switch); end - def parse_peek(switch, option); end - def parsing_options?; end - def switch?(arg); end - def switch_option(arg); end - - class << self - def to_switches(options); end - end -end - -Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp) - -Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp) - -Thor::Options::OPTS_END = T.let(T.unsafe(nil), String) - -Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp) - -Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp) - -Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp) - -module Thor::RakeCompat - include(::FileUtils::StreamUtils_) - include(::FileUtils) - # include(::Rake::FileUtilsExt) - # include(::Rake::DSL) - - class << self - def included(base); end - def rake_classes; end - end -end - -class Thor::RequiredArgumentMissingError < ::Thor::InvocationError -end - -module Thor::Sandbox -end - -module Thor::Shell - def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end - - def ask(*args, &block); end - def error(*args, &block); end - def file_collision(*args, &block); end - def no?(*args, &block); end - def print_in_columns(*args, &block); end - def print_table(*args, &block); end - def print_wrapped(*args, &block); end - def say(*args, &block); end - def say_status(*args, &block); end - def set_color(*args, &block); end - def shell; end - def shell=(_arg0); end - def terminal_width(*args, &block); end - def with_padding; end - def yes?(*args, &block); end - - protected - - def _shared_configuration; end -end - -class Thor::Shell::Basic - def initialize; end - - def ask(statement, *args); end - def base; end - def base=(_arg0); end - def error(statement); end - def file_collision(destination); end - def indent(count = T.unsafe(nil)); end - def mute; end - def mute?; end - def no?(statement, color = T.unsafe(nil)); end - def padding; end - def padding=(value); end - def print_in_columns(array); end - def print_table(array, options = T.unsafe(nil)); end - def print_wrapped(message, options = T.unsafe(nil)); end - def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end - def say_status(status, message, log_status = T.unsafe(nil)); end - def set_color(string, *_arg1); end - def terminal_width; end - def yes?(statement, color = T.unsafe(nil)); end - - protected - - def answer_match(possibilities, answer, case_insensitive); end - def as_unicode; end - def ask_filtered(statement, color, options); end - def ask_simply(statement, color, options); end - def can_display_colors?; end - def dynamic_width; end - def dynamic_width_stty; end - def dynamic_width_tput; end - def file_collision_help; end - def git_merge_tool; end - def is?(value); end - def lookup_color(color); end - def merge(destination, content); end - def merge_tool; end - def prepare_message(message, *color); end - def quiet?; end - def show_diff(destination, content); end - def stderr; end - def stdout; end - def truncate(string, width); end - def unix?; end -end - -Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) - -class Thor::Shell::Color < ::Thor::Shell::Basic - def set_color(string, *colors); end - - protected - - def are_colors_disabled?; end - def can_display_colors?; end - def diff_lcs_loaded?; end - def output_diff_line(diff); end - def show_diff(destination, content); end -end - -Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::RED = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String) - -Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String) - -class Thor::Shell::HTML < ::Thor::Shell::Basic - def ask(statement, color = T.unsafe(nil)); end - def set_color(string, *colors); end - - protected - - def can_display_colors?; end - def diff_lcs_loaded?; end - def output_diff_line(diff); end - def show_diff(destination, content); end -end - -Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String) - -Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String) - -Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), T::Array[T.untyped]) - -Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String) - -Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), T::Array[T.untyped]) - -Thor::Task = Thor::Command - -class Thor::UndefinedCommandError < ::Thor::Error - include(::DidYouMean::Correctable) - - def initialize(command, all_commands, namespace); end - - def all_commands; end - def command; end -end - -class Thor::UndefinedCommandError::SpellChecker - def initialize(error); end - - def corrections; end - def error; end - def spell_checker; end -end - -Thor::UndefinedTaskError = Thor::UndefinedCommandError - -class Thor::UnknownArgumentError < ::Thor::Error - include(::DidYouMean::Correctable) - - def initialize(switches, unknown); end - - def switches; end - def unknown; end -end - -class Thor::UnknownArgumentError::SpellChecker - def initialize(error); end - - def corrections; end - def error; end - def spell_checker; end -end - -module Thor::Util - class << self - def camel_case(str); end - def escape_globs(path); end - def escape_html(string); end - def find_by_namespace(namespace); end - def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end - def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end - def globs_for(path); end - def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end - def namespace_from_thor_class(constant); end - def namespaces_in_content(contents, file = T.unsafe(nil)); end - def ruby_command; end - def snake_case(str); end - def thor_classes_in(klass); end - def thor_root; end - def thor_root_glob; end - def user_home; end - end -end diff --git a/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi b/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi deleted file mode 100644 index 47476a24..00000000 --- a/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi +++ /dev/null @@ -1,32 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi sorbet-typed -# -# If you would like to make changes to this file, great! Please upstream any changes you make here: -# -# https://github.com/sorbet/sorbet-typed/edit/master/lib/yard/all/yard.rbi -# -# typed: strict - -class YARD::CodeObjects::Base - def initialize(namespace, name, *arg2); end -end -class YARD::CodeObjects::NamespaceObject < YARD::CodeObjects::Base - def mixins(*scopes); end -end -class YARD::CodeObjects::ClassObject < YARD::CodeObjects::NamespaceObject -end -class YARD::CodeObjects::ConstantObject < YARD::CodeObjects::Base -end -class YARD::CodeObjects::Proxy - def initialize(namespace, name, type = nil); end -end -class YARD::Handlers::Base - def handlers; end - def self.handlers; end -end -class YARD::Handlers::Ruby::Base < YARD::Handlers::Base -end -class YARD::Handlers::Ruby::AttributeHandler < YARD::Handlers::Ruby::Base -end -class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base -end diff --git a/sorbet/rbi/todo.rbi b/sorbet/rbi/todo.rbi deleted file mode 100644 index 53a05eb4..00000000 --- a/sorbet/rbi/todo.rbi +++ /dev/null @@ -1,8 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi todo - -# typed: strong -module T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions; end -module T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions; end -module T::Private::Methods::MethodHooks; end -module T::Private::Methods::SingletonMethodHooks; end diff --git a/sorbet/tapioca/config.yml b/sorbet/tapioca/config.yml new file mode 100644 index 00000000..886ae587 --- /dev/null +++ b/sorbet/tapioca/config.yml @@ -0,0 +1,13 @@ +gem: + # Add your `gem` command parameters here: + # + # exclude: + # - gem_name + # doc: true + # workers: 5 +dsl: + # Add your `dsl` command parameters here: + # + # exclude: + # - SomeGeneratorName + # workers: 5 diff --git a/sorbet/tapioca/require.rb b/sorbet/tapioca/require.rb new file mode 100644 index 00000000..ded77fe4 --- /dev/null +++ b/sorbet/tapioca/require.rb @@ -0,0 +1,7 @@ +# typed: strong +# frozen_string_literal: true + +# Add your extra requires here (`bin/tapioca require` can be used to boostrap this list) +require 'bundler/audit/task' +require 'rspec/core/rake_task' +require 'rubocop/rake_task' diff --git a/yard-sorbet.gemspec b/yard-sorbet.gemspec index 105a0afe..0038690e 100644 --- a/yard-sorbet.gemspec +++ b/yard-sorbet.gemspec @@ -40,6 +40,7 @@ Gem::Specification.new do |spec| spec.add_development_dependency 'rubocop-rspec', '~> 2.12.1' spec.add_development_dependency 'rubocop-sorbet', '~> 0.6.0' spec.add_development_dependency 'sorbet', '~> 0.5.9204' + spec.add_development_dependency 'tapioca', '~> 0.9.4' spec.add_runtime_dependency 'sorbet-runtime', '>= 0.5' spec.add_runtime_dependency 'yard', '>= 0.9' end